@porulle/plugin-procurement 0.1.0

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,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBnB,CAAC;AAEJ,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC;AAEJ,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBxB,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc5B,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB5B,CAAC;AAEJ,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,109 @@
+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().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().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().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/dist/services/grn-service.d.ts

@@ -0,0 +1,34 @@
+import type { PluginResult } from "@porulle/core";
+import type { Db, GoodsReceivedNote, GRNItem } from "../types.js";
+export declare class GRNService {
+    private db;
+    constructor(db: Db);
+    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>>;
+    list(orgId: string): Promise<PluginResult<GoodsReceivedNote[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<{
+        grn: GoodsReceivedNote;
+        items: GRNItem[];
+    }>>;
+    accept(orgId: string, id: string): Promise<PluginResult<GoodsReceivedNote>>;
+    private generateGRNNumber;
+}
+//# sourceMappingURL=grn-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grn-service.d.ts","sourceRoot":"","sources":["../../src/services/grn-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAElE,qBAAa,UAAU;IACT,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAC1F,KAAK,EAAE,KAAK,CAAC;YACX,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YACvD,eAAe,EAAE,MAAM,CAAC;YAAC,gBAAgB,EAAE,MAAM,CAAC;YAAC,gBAAgB,EAAE,MAAM,CAAC;YAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;YAAC,eAAe,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;SACvC,CAAC,CAAC;KACJ,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;IA0CtC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAK/D,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,GAAG,EAAE,iBAAiB,CAAC;QAAC,KAAK,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAAC;IAQvG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;YAYnE,iBAAiB;CAMhC"}

package/dist/services/grn-service.js

@@ -0,0 +1,74 @@
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { goodsReceivedNotes, grnItems, purchaseOrders, purchaseOrderItems } from "../schema.js";
+export class GRNService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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) {
+        const rows = await this.db.select().from(goodsReceivedNotes).where(eq(goodsReceivedNotes.organizationId, orgId));
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        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, id) {
+        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]);
+    }
+    async generateGRNNumber(orgId) {
+        const countRows = await this.db.select({ count: sql `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/dist/services/po-service.d.ts

@@ -0,0 +1,31 @@
+import type { PluginResult } from "@porulle/core";
+import type { Db, PurchaseOrder, PurchaseOrderItem } from "../types.js";
+export declare class PurchaseOrderService {
+    private db;
+    constructor(db: Db);
+    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>>;
+    list(orgId: string, status?: string): Promise<PluginResult<PurchaseOrder[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<{
+        po: PurchaseOrder;
+        items: PurchaseOrderItem[];
+    }>>;
+    submit(orgId: string, id: string): Promise<PluginResult<PurchaseOrder>>;
+    approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<PurchaseOrder>>;
+    cancel(orgId: string, id: string): Promise<PluginResult<PurchaseOrder>>;
+    private transition;
+    private generatePONumber;
+}
+//# sourceMappingURL=po-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"po-service.d.ts","sourceRoot":"","sources":["../../src/services/po-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAExE,qBAAa,oBAAoB;IACnB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAC1C,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACrH,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAuBlC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;IAO5E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,EAAE,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,iBAAiB,EAAE,CAAA;KAAE,CAAC,CAAC;IAO5G,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAIvE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAS5F,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;YAO/D,UAAU;YAQV,gBAAgB;CAM/B"}

package/dist/services/po-service.js

@@ -0,0 +1,77 @@
+import { eq, and, sql } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { purchaseOrders, purchaseOrderItems } from "../schema.js";
+export class PurchaseOrderService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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, status) {
+        const conditions = [eq(purchaseOrders.organizationId, orgId)];
+        if (status)
+            conditions.push(eq(purchaseOrders.status, status));
+        const rows = await this.db.select().from(purchaseOrders).where(and(...conditions));
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        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, id) {
+        return this.transition(orgId, id, "draft", "pending_approval");
+    }
+    async approve(orgId, id, approvedBy) {
+        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, id) {
+        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]);
+    }
+    async transition(orgId, id, from, to) {
+        const rows = await this.db.update(purchaseOrders).set({ status: to, updatedAt: new Date() })
+            .where(and(eq(purchaseOrders.id, id), eq(purchaseOrders.organizationId, orgId), eq(purchaseOrders.status, from)))
+            .returning();
+        if (rows.length === 0)
+            return Err(`PO not found or not in '${from}' status`);
+        return Ok(rows[0]);
+    }
+    async generatePONumber(orgId) {
+        const countRows = await this.db.select({ count: sql `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/dist/services/supplier-service.d.ts

@@ -0,0 +1,30 @@
+import type { PluginResult } from "@porulle/core";
+import type { Db, Supplier, SupplierItem } from "../types.js";
+export declare class SupplierService {
+    private db;
+    constructor(db: Db);
+    create(orgId: string, input: {
+        name: string;
+        code: string;
+        contactName?: string;
+        contactEmail?: string;
+        contactPhone?: string;
+        paymentTermsDays?: number;
+        currency?: string;
+    }): Promise<PluginResult<Supplier>>;
+    list(orgId: string): Promise<PluginResult<Supplier[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<{
+        supplier: Supplier;
+        items: SupplierItem[];
+    }>>;
+    addItem(supplierId: string, input: {
+        entityId: string;
+        variantId?: string;
+        supplierSku?: string;
+        unitCost: number;
+        minOrderQuantity?: number;
+        leadTimeDays?: number;
+        isPreferred?: boolean;
+    }): Promise<PluginResult<SupplierItem>>;
+}
+//# sourceMappingURL=supplier-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supplier-service.d.ts","sourceRoot":"","sources":["../../src/services/supplier-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,eAAe,CAAC;AAEnE,OAAO,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE9D,qBAAa,eAAe;IACd,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QACxE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrE,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IAQ7B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;IAKtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC,CAAC;IAOxG,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE;QACvC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;KACzE,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;CAIxC"}

package/dist/services/supplier-service.js

@@ -0,0 +1,32 @@
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { suppliers, supplierItems } from "../schema.js";
+export class SupplierService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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) {
+        const rows = await this.db.select().from(suppliers).where(eq(suppliers.organizationId, orgId));
+        return Ok(rows);
+    }
+    async getById(orgId, id) {
+        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, input) {
+        const rows = await this.db.insert(supplierItems).values({ supplierId, ...input }).returning();
+        return Ok(rows[0]);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+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";
+//# 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,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC9H,MAAM,MAAM,QAAQ,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACrD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC,YAAY,CAAC;AACnD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,kBAAkB,GAAG,UAAU,GAAG,MAAM,GAAG,oBAAoB,GAAG,UAAU,GAAG,WAAW,CAAC"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@porulle/plugin-procurement",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    },
+    "./schema": {
+      "bun": "./src/schema.ts",
+      "import": "./dist/schema.js",
+      "require": "./dist/schema.js",
+      "types": "./src/schema.ts"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@porulle/core": "workspace:*",
+    "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": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "zod": ">=4.0.0"
+  },
+  "description": "Suppliers with catalog links, purchase orders through approval, and goods-received notes for inbound receiving.",
+  "homepage": "https://porulle-docs.vercel.app",
+  "bugs": {
+    "url": "https://github.com/asyncdotengineering/porulle/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asyncdotengineering/porulle.git",
+    "directory": "packages/plugins/plugin-procurement"
+  },
+  "author": "Porulle contributors"
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { suppliers, supplierItems, purchaseOrders, purchaseOrderItems, goodsReceivedNotes, grnItems } from "./schema.js";
+import { SupplierService } from "./services/supplier-service.js";
+import { PurchaseOrderService } from "./services/po-service.js";
+import { GRNService } from "./services/grn-service.js";
+import { buildProcurementRoutes } from "./routes/procurement.js";
+export type { Db } from "./types.js";
+export { SupplierService } from "./services/supplier-service.js";
+export { PurchaseOrderService } from "./services/po-service.js";
+export { GRNService } from "./services/grn-service.js";
+
+export function procurementPlugin() {
+  return defineCommercePlugin({
+    id: "procurement",
+    version: "1.0.0",
+    permissions: [
+      { scope: "procurement:admin", description: "Approve POs, manage suppliers, accept GRNs." },
+      { scope: "procurement:create", description: "Create POs, create GRNs." },
+      { scope: "procurement:read", description: "View POs, GRNs, suppliers." },
+    ],
+    schema: () => ({ suppliers, supplierItems, purchaseOrders, purchaseOrderItems, goodsReceivedNotes, grnItems }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db;
+      if (!db) return [];
+      return buildProcurementRoutes(new SupplierService(db), new PurchaseOrderService(db), new GRNService(db), ctx);
+    },
+  });
+}