@unifiedcommerce/plugin-production 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+import type { productionBoms, productionBomItems, productionOrders, productionConsumption } from "./schema";
+export type BOM = typeof productionBoms.$inferSelect;
+export type BOMItem = typeof productionBomItems.$inferSelect;
+export type ProductionOrder = typeof productionOrders.$inferSelect;
+export type Consumption = typeof productionConsumption.$inferSelect;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC5G,MAAM,MAAM,GAAG,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACrD,MAAM,MAAM,OAAO,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,WAAW,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@unifiedcommerce/plugin-production",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@unifiedcommerce/core": "*",
+    "drizzle-orm": "^0.45.1",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^24.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+import { defineCommercePlugin } from "@unifiedcommerce/core";
+import { productionBoms, productionBomItems, productionOrders, productionConsumption } from "./schema";
+import { ProductionService } from "./services/production-service";
+import { ProductionOrderService } from "./services/production-order-service";
+import { buildProductionRoutes } from "./routes/production";
+import type { Db } from "./types";
+
+export type { Db } from "./types";
+export { ProductionService } from "./services/production-service";
+export { ProductionOrderService } from "./services/production-order-service";
+
+export function productionPlugin() {
+  return defineCommercePlugin({
+    id: "production",
+    version: "1.0.0",
+    permissions: [
+      { scope: "production:admin", description: "Create/edit BOMs, cost rollup, cancel orders." },
+      { scope: "production:create", description: "Create and manage production orders." },
+      { scope: "production:read", description: "View BOMs, orders, and BOM explosion." },
+    ],
+    schema: () => ({ productionBoms, productionBomItems, productionOrders, productionConsumption }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db as unknown as Db;
+      if (!db) return [];
+      return buildProductionRoutes(
+        new ProductionService(db),
+        new ProductionOrderService(db),
+        ctx,
+      );
+    },
+  });
+}

package/src/routes/production.ts

@@ -0,0 +1,178 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { ProductionService } from "../services/production-service";
+import type { ProductionOrderService } from "../services/production-order-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildProductionRoutes(
+  bomSvc: ProductionService,
+  orderSvc: ProductionOrderService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Production", "/production", ctx);
+
+  // --- BOM Routes ---
+
+  r.post("/boms").summary("Create BOM").permission("production:admin")
+    .input(z.object({
+      entityId: z.string().uuid(),
+      name: z.string().min(1),
+      yieldQuantity: z.number().int().positive().optional(),
+      yieldUomId: z.string().uuid().optional(),
+      level: z.number().int().min(0).optional(),
+      items: z.array(z.object({
+        entityId: z.string().uuid(),
+        itemName: z.string().min(1),
+        quantity: z.number().int().positive(),
+        unitCost: z.number().int().min(0),
+        uomId: z.string().uuid().optional(),
+        isSubAssembly: z.boolean().optional(),
+        subBomId: z.string().uuid().optional(),
+      })).min(1),
+    }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as {
+        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 }>;
+      };
+      const result = await bomSvc.createBOM(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/boms").summary("List BOMs").permission("production:read")
+    .handler(async ({ orgId }) => {
+      const result = await bomSvc.listBOMs(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/boms/{id}").summary("Get BOM").permission("production:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await bomSvc.getBOM(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/boms/{id}/items").summary("Add item to BOM").permission("production:admin")
+    .input(z.object({
+      entityId: z.string().uuid(),
+      itemName: z.string().min(1),
+      quantity: z.number().int().positive(),
+      unitCost: z.number().int().min(0),
+      uomId: z.string().uuid().optional(),
+      isSubAssembly: z.boolean().optional(),
+      subBomId: z.string().uuid().optional(),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as {
+        entityId: string; itemName: string; quantity: number; unitCost: number;
+        uomId?: string; isSubAssembly?: boolean; subBomId?: string;
+      };
+      const result = await bomSvc.addBOMItem(orgId, params.id!, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/boms/{id}/cost-rollup").summary("Cost rollup").permission("production:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await bomSvc.costRollup(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/boms/{id}/explode").summary("BOM explosion").permission("production:read")
+    .input(z.object({ quantity: z.number().int().positive() }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { quantity: number };
+      const result = await bomSvc.explode(orgId, params.id!, body.quantity);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // --- Production Order Routes ---
+
+  r.post("/orders").summary("Create production order").permission("production:create")
+    .input(z.object({
+      bomId: z.string().uuid(),
+      entityId: z.string().uuid(),
+      quantity: z.number().int().positive(),
+      warehouseId: z.string().uuid(),
+      plannedDate: z.string(),
+      notes: z.string().optional(),
+    }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { bomId: string; entityId: string; quantity: number; warehouseId: string; plannedDate: string; notes?: string };
+      const result = await orderSvc.create(orgId, {
+        ...body,
+        plannedDate: new Date(body.plannedDate),
+      });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/orders").summary("List production orders").permission("production:read")
+    .query(z.object({ status: z.enum(["planned", "in_progress", "completed", "cancelled"]).optional() }))
+    .handler(async ({ query, orgId }) => {
+      const q = query as { status?: string };
+      const result = await orderSvc.list(orgId, q.status);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/orders/{id}").summary("Get production order").permission("production:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await orderSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/orders/{id}/start").summary("Start production order").permission("production:create")
+    .input(z.object({ producedBy: z.string().min(1) }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { producedBy: string };
+      const result = await orderSvc.start(orgId, params.id!, body.producedBy);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/orders/{id}/consume").summary("Record consumption").permission("production:create")
+    .input(z.object({
+      items: z.array(z.object({
+        entityId: z.string().uuid(),
+        variantId: z.string().uuid().optional(),
+        plannedQuantity: z.number().int().min(0),
+        actualQuantity: z.number().int().min(0),
+        uomId: z.string().uuid().optional(),
+        unitCost: z.number().int().min(0),
+        batchNumber: z.string().optional(),
+      })).min(1),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as {
+        items: Array<{
+          entityId: string; variantId?: string; plannedQuantity: number;
+          actualQuantity: number; uomId?: string; unitCost: number; batchNumber?: string;
+        }>;
+      };
+      const result = await orderSvc.recordConsumption(orgId, params.id!, body.items);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/orders/{id}/complete").summary("Complete production order").permission("production:create")
+    .handler(async ({ params, orgId }) => {
+      const result = await orderSvc.complete(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/orders/{id}/cancel").summary("Cancel production order").permission("production:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await orderSvc.cancel(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,75 @@
+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/src/services/production-order-service.ts

@@ -0,0 +1,182 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { productionBoms, productionBomItems, productionOrders, productionConsumption } from "../schema";
+import type { Db, ProductionOrder, Consumption } from "../types";
+
+export class ProductionOrderService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    bomId: string;
+    entityId: string;
+    quantity: number;
+    warehouseId: string;
+    plannedDate: Date;
+    notes?: string;
+  }): Promise<PluginResult<ProductionOrder>> {
+    // 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: string, status?: string): Promise<PluginResult<ProductionOrder[]>> {
+    const conditions = [eq(productionOrders.organizationId, orgId)];
+    if (status) {
+      conditions.push(eq(productionOrders.status, status as "planned" | "in_progress" | "completed" | "cancelled"));
+    }
+    const rows = await this.db.select().from(productionOrders).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<ProductionOrder & { consumption: Consumption[] }>> {
+    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: string, id: string, producedBy: string): Promise<PluginResult<ProductionOrder>> {
+    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: string, orderId: string, items: Array<{
+    entityId: string;
+    variantId?: string;
+    plannedQuantity: number;
+    actualQuantity: number;
+    uomId?: string;
+    unitCost: number;
+    batchNumber?: string;
+  }>): Promise<PluginResult<Consumption[]>> {
+    // 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: Consumption[] = [];
+    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: string, id: string): Promise<PluginResult<ProductionOrder & { consumption: Consumption[] }>> {
+    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: string, id: string): Promise<PluginResult<ProductionOrder>> {
+    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]!);
+  }
+
+  private async generateOrderNumber(orgId: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`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")}`;
+  }
+}