@porulle/plugin-procurement 0.1.0

package/src/routes/procurement.ts

@@ -0,0 +1,135 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+import type { SupplierService } from "../services/supplier-service.js";
+import type { PurchaseOrderService } from "../services/po-service.js";
+import type { GRNService } from "../services/grn-service.js";
+import type { PluginRouteRegistration } from "@porulle/core";
+
+export function buildProcurementRoutes(
+  supplierSvc: SupplierService, poSvc: PurchaseOrderService, grnSvc: GRNService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Procurement", "/procurement", ctx);
+
+  // Suppliers
+  r.post("/suppliers").summary("Register supplier").permission("procurement:admin")
+    .input(z.object({ name: z.string().min(1), code: z.string().min(1), contactName: z.string().optional(), contactEmail: z.string().email().optional(), contactPhone: z.string().optional(), paymentTermsDays: z.number().int().optional(), currency: z.string().optional() }))
+    .handler(async ({ input, orgId }) => {
+      const result = await supplierSvc.create(orgId, input as Parameters<typeof supplierSvc.create>[1]);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/suppliers").summary("List suppliers").permission("procurement:read")
+    .handler(async ({ orgId }) => {
+      const result = await supplierSvc.list(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/suppliers/{id}").summary("Get supplier with items").permission("procurement:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await supplierSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/suppliers/{id}/items").summary("Link item to supplier").permission("procurement:admin")
+    .input(z.object({ entityId: z.string().uuid(), variantId: z.string().uuid().optional(), supplierSku: z.string().optional(), unitCost: z.number().int().positive(), minOrderQuantity: z.number().int().optional(), leadTimeDays: z.number().int().optional(), isPreferred: z.boolean().optional() }))
+    .handler(async ({ params, input }) => {
+      const result = await supplierSvc.addItem(params.id!, input as Parameters<typeof supplierSvc.addItem>[1]);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // Purchase Orders
+  r.post("/purchase-orders").summary("Create purchase order").permission("procurement:create")
+    .input(z.object({
+      supplierId: z.string().uuid(), warehouseId: z.string().uuid(), notes: z.string().optional(),
+      expectedDelivery: z.string().optional(),
+      items: z.array(z.object({ entityId: z.string().uuid(), variantId: z.string().uuid().optional(), itemName: z.string(), quantityOrdered: z.number().int().positive(), unitCost: z.number().int().positive() })).min(1),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as Parameters<typeof poSvc.create>[1];
+      const result = await poSvc.create(orgId, { ...body, requestedBy: actor!.userId });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/purchase-orders").summary("List purchase orders").permission("procurement:read")
+    .query(z.object({ status: z.string().optional() }))
+    .handler(async ({ query, orgId }) => {
+      const result = await poSvc.list(orgId, (query as { status?: string }).status);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/purchase-orders/{id}").summary("Get PO with items").permission("procurement:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await poSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/purchase-orders/{id}/submit").summary("Submit PO for approval").permission("procurement:create")
+    .handler(async ({ params, orgId }) => {
+      const result = await poSvc.submit(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/purchase-orders/{id}/approve").summary("Approve PO").permission("procurement:admin")
+    .handler(async ({ params, actor, orgId }) => {
+      const result = await poSvc.approve(orgId, params.id!, actor!.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/purchase-orders/{id}/cancel").summary("Cancel PO").permission("procurement:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await poSvc.cancel(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // GRN
+  r.post("/grn").summary("Create GRN").permission("procurement:create")
+    .input(z.object({
+      poId: z.string().uuid(), supplierId: z.string().uuid(), warehouseId: z.string().uuid(), notes: z.string().optional(),
+      items: z.array(z.object({
+        poItemId: z.string().uuid(), entityId: z.string().uuid(), variantId: z.string().uuid().optional(),
+        quantityOrdered: z.number().int(), quantityReceived: z.number().int(), quantityAccepted: z.number().int(),
+        quantityRejected: z.number().int().optional(), rejectionReason: z.string().optional(),
+        batchNumber: z.string().optional(), expiryDate: z.string().optional(), unitCost: z.number().int(),
+      })).min(1),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as Parameters<typeof grnSvc.create>[1];
+      const result = await grnSvc.create(orgId, { ...body, receivedBy: actor!.userId });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/grn").summary("List GRNs").permission("procurement:read")
+    .handler(async ({ orgId }) => {
+      const result = await grnSvc.list(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/grn/{id}").summary("Get GRN with items").permission("procurement:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await grnSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/grn/{id}/accept").summary("Accept GRN").permission("procurement:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await grnSvc.accept(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,115 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, jsonb, index, uniqueIndex } from "@porulle/core/drizzle";
+
+export const suppliers = pgTable("suppliers", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  name: text("name").notNull(),
+  code: text("code").notNull(),
+  contactName: text("contact_name"),
+  contactEmail: text("contact_email"),
+  contactPhone: text("contact_phone"),
+  paymentTermsDays: integer("payment_terms_days").notNull().default(30),
+  currency: text("currency").notNull().default("USD"),
+  taxId: text("tax_id"),
+  isActive: boolean("is_active").notNull().default(true),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_suppliers_org").on(table.organizationId),
+  codeUnique: uniqueIndex("suppliers_org_code_unique").on(table.organizationId, table.code),
+}));
+
+export const supplierItems = pgTable("supplier_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  supplierId: uuid("supplier_id").references(() => suppliers.id, { onDelete: "cascade" }).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  supplierSku: text("supplier_sku"),
+  unitCost: integer("unit_cost").notNull(),
+  minOrderQuantity: integer("min_order_quantity").notNull().default(1),
+  leadTimeDays: integer("lead_time_days").notNull().default(1),
+  isPreferred: boolean("is_preferred").notNull().default(false),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  supplierIdx: index("idx_supplier_items_supplier").on(table.supplierId),
+}));
+
+export const purchaseOrders = pgTable("purchase_orders", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  poNumber: text("po_number").notNull(),
+  supplierId: uuid("supplier_id").references(() => suppliers.id).notNull(),
+  status: text("status", { enum: ["draft", "pending_approval", "approved", "sent", "partially_received", "received", "cancelled"] }).notNull().default("draft"),
+  warehouseId: uuid("warehouse_id").notNull(),
+  requestedBy: text("requested_by").notNull(),
+  approvedBy: text("approved_by"),
+  approvedAt: timestamp("approved_at", { withTimezone: true }),
+  expectedDelivery: timestamp("expected_delivery", { withTimezone: true }),
+  subtotal: integer("subtotal").notNull().default(0),
+  taxTotal: integer("tax_total").notNull().default(0),
+  grandTotal: integer("grand_total").notNull().default(0),
+  notes: text("notes"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_purchase_orders_org").on(table.organizationId),
+  statusIdx: index("idx_purchase_orders_status").on(table.status),
+  poNumUnique: uniqueIndex("purchase_orders_org_po_unique").on(table.organizationId, table.poNumber),
+}));
+
+export const purchaseOrderItems = pgTable("purchase_order_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  poId: uuid("po_id").references(() => purchaseOrders.id, { onDelete: "cascade" }).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  itemName: text("item_name").notNull(),
+  quantityOrdered: integer("quantity_ordered").notNull(),
+  quantityReceived: integer("quantity_received").notNull().default(0),
+  unitCost: integer("unit_cost").notNull(),
+  totalCost: integer("total_cost").notNull(),
+  notes: text("notes"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  poIdx: index("idx_po_items_po").on(table.poId),
+}));
+
+export const goodsReceivedNotes = pgTable("goods_received_notes", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  grnNumber: text("grn_number").notNull(),
+  poId: uuid("po_id").references(() => purchaseOrders.id).notNull(),
+  supplierId: uuid("supplier_id").references(() => suppliers.id).notNull(),
+  warehouseId: uuid("warehouse_id").notNull(),
+  receivedBy: text("received_by").notNull(),
+  status: text("status", { enum: ["draft", "inspecting", "accepted", "accepted_with_discrepancy", "rejected"] }).notNull().default("draft"),
+  receivedAt: timestamp("received_at", { withTimezone: true }).defaultNow().notNull(),
+  notes: text("notes"),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_grn_org").on(table.organizationId),
+  poIdx: index("idx_grn_po").on(table.poId),
+  grnNumUnique: uniqueIndex("grn_org_number_unique").on(table.organizationId, table.grnNumber),
+}));
+
+export const grnItems = pgTable("grn_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  grnId: uuid("grn_id").references(() => goodsReceivedNotes.id, { onDelete: "cascade" }).notNull(),
+  poItemId: uuid("po_item_id").references(() => purchaseOrderItems.id).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  quantityOrdered: integer("quantity_ordered").notNull(),
+  quantityReceived: integer("quantity_received").notNull(),
+  quantityAccepted: integer("quantity_accepted").notNull(),
+  quantityRejected: integer("quantity_rejected").notNull().default(0),
+  rejectionReason: text("rejection_reason"),
+  batchNumber: text("batch_number"),
+  expiryDate: timestamp("expiry_date", { withTimezone: true }),
+  unitCost: integer("unit_cost").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  grnIdx: index("idx_grn_items_grn").on(table.grnId),
+}));

package/src/services/grn-service.ts

@@ -0,0 +1,91 @@
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { goodsReceivedNotes, grnItems, purchaseOrders, purchaseOrderItems } from "../schema.js";
+import type { Db, GoodsReceivedNote, GRNItem } from "../types.js";
+
+export class GRNService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    poId: string; supplierId: string; warehouseId: string; receivedBy: string; notes?: string;
+    items: Array<{
+      poItemId: string; entityId: string; variantId?: string;
+      quantityOrdered: number; quantityReceived: number; quantityAccepted: number;
+      quantityRejected?: number; rejectionReason?: string; batchNumber?: string;
+      expiryDate?: string; unitCost: number;
+    }>;
+  }): Promise<PluginResult<GoodsReceivedNote>> {
+    const grnNumber = await this.generateGRNNumber(orgId);
+
+    const rows = await this.db.insert(goodsReceivedNotes).values({
+      organizationId: orgId, grnNumber, poId: input.poId, supplierId: input.supplierId,
+      warehouseId: input.warehouseId, receivedBy: input.receivedBy, notes: input.notes,
+    }).returning();
+    const grn = rows[0]!;
+
+    for (const item of input.items) {
+      await this.db.insert(grnItems).values({
+        grnId: grn.id, poItemId: item.poItemId, entityId: item.entityId,
+        variantId: item.variantId, quantityOrdered: item.quantityOrdered,
+        quantityReceived: item.quantityReceived, quantityAccepted: item.quantityAccepted,
+        quantityRejected: item.quantityRejected ?? 0, rejectionReason: item.rejectionReason,
+        batchNumber: item.batchNumber,
+        ...(item.expiryDate ? { expiryDate: new Date(item.expiryDate) } : {}),
+        unitCost: item.unitCost,
+      });
+
+      // Update PO item received quantity
+      await this.db.update(purchaseOrderItems).set({
+        quantityReceived: sql`${purchaseOrderItems.quantityReceived} + ${item.quantityReceived}`,
+      }).where(eq(purchaseOrderItems.id, item.poItemId));
+    }
+
+    // Check if PO is fully received
+    const poItems = await this.db.select().from(purchaseOrderItems).where(eq(purchaseOrderItems.poId, input.poId));
+    const allReceived = poItems.every(pi => pi.quantityReceived >= pi.quantityOrdered);
+    const someReceived = poItems.some(pi => pi.quantityReceived > 0);
+
+    if (allReceived) {
+      await this.db.update(purchaseOrders).set({ status: "received", updatedAt: new Date() })
+        .where(eq(purchaseOrders.id, input.poId));
+    } else if (someReceived) {
+      await this.db.update(purchaseOrders).set({ status: "partially_received", updatedAt: new Date() })
+        .where(eq(purchaseOrders.id, input.poId));
+    }
+
+    return Ok(grn);
+  }
+
+  async list(orgId: string): Promise<PluginResult<GoodsReceivedNote[]>> {
+    const rows = await this.db.select().from(goodsReceivedNotes).where(eq(goodsReceivedNotes.organizationId, orgId));
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<{ grn: GoodsReceivedNote; items: GRNItem[] }>> {
+    const rows = await this.db.select().from(goodsReceivedNotes)
+      .where(and(eq(goodsReceivedNotes.id, id), eq(goodsReceivedNotes.organizationId, orgId)));
+    if (rows.length === 0) return Err("GRN not found");
+    const items = await this.db.select().from(grnItems).where(eq(grnItems.grnId, id));
+    return Ok({ grn: rows[0]!, items });
+  }
+
+  async accept(orgId: string, id: string): Promise<PluginResult<GoodsReceivedNote>> {
+    const items = await this.db.select().from(grnItems)
+      .where(eq(grnItems.grnId, id));
+    const hasDiscrepancy = items.some(i => i.quantityRejected > 0);
+    const newStatus = hasDiscrepancy ? "accepted_with_discrepancy" : "accepted";
+
+    const rows = await this.db.update(goodsReceivedNotes).set({ status: newStatus })
+      .where(and(eq(goodsReceivedNotes.id, id), eq(goodsReceivedNotes.organizationId, orgId))).returning();
+    if (rows.length === 0) return Err("GRN not found");
+    return Ok(rows[0]!);
+  }
+
+  private async generateGRNNumber(orgId: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`COUNT(*)`.as("count") })
+      .from(goodsReceivedNotes).where(eq(goodsReceivedNotes.organizationId, orgId));
+    const seq = Number(countRows[0]?.count ?? 0) + 1;
+    return `GRN-${String(seq).padStart(4, "0")}`;
+  }
+}

package/src/services/po-service.ts

@@ -0,0 +1,85 @@
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { purchaseOrders, purchaseOrderItems } from "../schema.js";
+import type { Db, PurchaseOrder, PurchaseOrderItem } from "../types.js";
+
+export class PurchaseOrderService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    supplierId: string; warehouseId: string; requestedBy: string;
+    expectedDelivery?: string; notes?: string;
+    items: Array<{ entityId: string; variantId?: string; itemName: string; quantityOrdered: number; unitCost: number }>;
+  }): Promise<PluginResult<PurchaseOrder>> {
+    const poNumber = await this.generatePONumber(orgId);
+    let subtotal = 0;
+    for (const item of input.items) subtotal += item.quantityOrdered * item.unitCost;
+
+    const rows = await this.db.insert(purchaseOrders).values({
+      organizationId: orgId, poNumber, supplierId: input.supplierId,
+      warehouseId: input.warehouseId, requestedBy: input.requestedBy,
+      ...(input.expectedDelivery ? { expectedDelivery: new Date(input.expectedDelivery) } : {}),
+      subtotal, grandTotal: subtotal, notes: input.notes,
+    }).returning();
+    const po = rows[0]!;
+
+    for (const item of input.items) {
+      await this.db.insert(purchaseOrderItems).values({
+        poId: po.id, entityId: item.entityId, variantId: item.variantId,
+        itemName: item.itemName, quantityOrdered: item.quantityOrdered,
+        unitCost: item.unitCost, totalCost: item.quantityOrdered * item.unitCost,
+      });
+    }
+    return Ok(po);
+  }
+
+  async list(orgId: string, status?: string): Promise<PluginResult<PurchaseOrder[]>> {
+    const conditions = [eq(purchaseOrders.organizationId, orgId)];
+    if (status) conditions.push(eq(purchaseOrders.status, status as PurchaseOrder["status"]));
+    const rows = await this.db.select().from(purchaseOrders).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<{ po: PurchaseOrder; items: PurchaseOrderItem[] }>> {
+    const rows = await this.db.select().from(purchaseOrders).where(and(eq(purchaseOrders.id, id), eq(purchaseOrders.organizationId, orgId)));
+    if (rows.length === 0) return Err("Purchase order not found");
+    const items = await this.db.select().from(purchaseOrderItems).where(eq(purchaseOrderItems.poId, id));
+    return Ok({ po: rows[0]!, items });
+  }
+
+  async submit(orgId: string, id: string): Promise<PluginResult<PurchaseOrder>> {
+    return this.transition(orgId, id, "draft", "pending_approval");
+  }
+
+  async approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<PurchaseOrder>> {
+    const rows = await this.db.update(purchaseOrders).set({
+      status: "approved", approvedBy, approvedAt: new Date(), updatedAt: new Date(),
+    }).where(and(eq(purchaseOrders.id, id), eq(purchaseOrders.organizationId, orgId), eq(purchaseOrders.status, "pending_approval")))
+      .returning();
+    if (rows.length === 0) return Err("PO not found or not in pending_approval status");
+    return Ok(rows[0]!);
+  }
+
+  async cancel(orgId: string, id: string): Promise<PluginResult<PurchaseOrder>> {
+    const rows = await this.db.update(purchaseOrders).set({ status: "cancelled", updatedAt: new Date() })
+      .where(and(eq(purchaseOrders.id, id), eq(purchaseOrders.organizationId, orgId))).returning();
+    if (rows.length === 0) return Err("PO not found");
+    return Ok(rows[0]!);
+  }
+
+  private async transition(orgId: string, id: string, from: string, to: string): Promise<PluginResult<PurchaseOrder>> {
+    const rows = await this.db.update(purchaseOrders).set({ status: to as PurchaseOrder["status"], updatedAt: new Date() })
+      .where(and(eq(purchaseOrders.id, id), eq(purchaseOrders.organizationId, orgId), eq(purchaseOrders.status, from as PurchaseOrder["status"])))
+      .returning();
+    if (rows.length === 0) return Err(`PO not found or not in '${from}' status`);
+    return Ok(rows[0]!);
+  }
+
+  private async generatePONumber(orgId: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`COUNT(*)`.as("count") })
+      .from(purchaseOrders).where(eq(purchaseOrders.organizationId, orgId));
+    const seq = Number(countRows[0]?.count ?? 0) + 1;
+    return `PO-${String(seq).padStart(4, "0")}`;
+  }
+}

package/src/services/supplier-service.ts

@@ -0,0 +1,40 @@
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult, PluginResultErr } from "@porulle/core";
+import { suppliers, supplierItems } from "../schema.js";
+import type { Db, Supplier, SupplierItem } from "../types.js";
+
+export class SupplierService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    name: string; code: string; contactName?: string; contactEmail?: string;
+    contactPhone?: string; paymentTermsDays?: number; currency?: string;
+  }): Promise<PluginResult<Supplier>> {
+    const existing = await this.db.select().from(suppliers)
+      .where(and(eq(suppliers.organizationId, orgId), eq(suppliers.code, input.code)));
+    if (existing.length > 0) return Err(`Supplier code '${input.code}' already exists`);
+    const rows = await this.db.insert(suppliers).values({ organizationId: orgId, ...input }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async list(orgId: string): Promise<PluginResult<Supplier[]>> {
+    const rows = await this.db.select().from(suppliers).where(eq(suppliers.organizationId, orgId));
+    return Ok(rows);
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<{ supplier: Supplier; items: SupplierItem[] }>> {
+    const rows = await this.db.select().from(suppliers).where(and(eq(suppliers.id, id), eq(suppliers.organizationId, orgId)));
+    if (rows.length === 0) return Err("Supplier not found");
+    const items = await this.db.select().from(supplierItems).where(eq(supplierItems.supplierId, id));
+    return Ok({ supplier: rows[0]!, items });
+  }
+
+  async addItem(supplierId: string, input: {
+    entityId: string; variantId?: string; supplierSku?: string; unitCost: number;
+    minOrderQuantity?: number; leadTimeDays?: number; isPreferred?: boolean;
+  }): Promise<PluginResult<SupplierItem>> {
+    const rows = await this.db.insert(supplierItems).values({ supplierId, ...input }).returning();
+    return Ok(rows[0]!);
+  }
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export type { PluginDb as Db } from "@porulle/core";
+import type { suppliers, supplierItems, purchaseOrders, purchaseOrderItems, goodsReceivedNotes, grnItems } from "./schema.js";
+export type Supplier = typeof suppliers.$inferSelect;
+export type SupplierItem = typeof supplierItems.$inferSelect;
+export type PurchaseOrder = typeof purchaseOrders.$inferSelect;
+export type PurchaseOrderItem = typeof purchaseOrderItems.$inferSelect;
+export type GoodsReceivedNote = typeof goodsReceivedNotes.$inferSelect;
+export type GRNItem = typeof grnItems.$inferSelect;
+export type POStatus = "draft" | "pending_approval" | "approved" | "sent" | "partially_received" | "received" | "cancelled";