@unifiedcommerce/plugin-warehouse 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+import type { warehouseBins, stockTransfers, stockTransferItems, wastageNotes, wastageNoteItems, stockReconciliations, reconciliationItems } from "./schema";
+export type WarehouseBin = typeof warehouseBins.$inferSelect;
+export type StockTransfer = typeof stockTransfers.$inferSelect;
+export type StockTransferItem = typeof stockTransferItems.$inferSelect;
+export type WastageNote = typeof wastageNotes.$inferSelect;
+export type WastageNoteItem = typeof wastageNoteItems.$inferSelect;
+export type StockReconciliation = typeof stockReconciliations.$inferSelect;
+export type ReconciliationItem = typeof reconciliationItems.$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,aAAa,EAAE,cAAc,EAAE,kBAAkB,EAAE,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC7J,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,WAAW,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC3D,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,mBAAmB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC3E,MAAM,MAAM,kBAAkB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAC"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@unifiedcommerce/plugin-warehouse",
+  "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,31 @@
+import { defineCommercePlugin } from "@unifiedcommerce/core";
+import { warehouseBins, stockTransfers, stockTransferItems, wastageNotes, wastageNoteItems, stockReconciliations, reconciliationItems } from "./schema";
+import { TransferService } from "./services/transfer-service";
+import { WastageService } from "./services/wastage-service";
+import { ReconciliationService } from "./services/reconciliation-service";
+import { buildWarehouseRoutes } from "./routes/warehouse";
+import type { Db } from "./types";
+
+export type { Db } from "./types";
+export { TransferService } from "./services/transfer-service";
+export { WastageService } from "./services/wastage-service";
+export { ReconciliationService } from "./services/reconciliation-service";
+
+export function warehousePlugin() {
+  return defineCommercePlugin({
+    id: "warehouse",
+    version: "1.0.0",
+    permissions: [
+      { scope: "warehouse:admin", description: "Approve transfers, wastage, reconciliations." },
+      { scope: "warehouse:operate", description: "Create transfers, wastage notes, reconciliations." },
+      { scope: "warehouse:read", description: "View transfers, wastage, reconciliations." },
+    ],
+    schema: () => ({ warehouseBins, stockTransfers, stockTransferItems, wastageNotes, wastageNoteItems, stockReconciliations, reconciliationItems }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db as unknown as Db;
+      if (!db) return [];
+      return buildWarehouseRoutes(new TransferService(db), new WastageService(db), new ReconciliationService(db), ctx);
+    },
+  });
+}

package/src/routes/warehouse.ts

@@ -0,0 +1,134 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { TransferService } from "../services/transfer-service";
+import type { WastageService } from "../services/wastage-service";
+import type { ReconciliationService } from "../services/reconciliation-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildWarehouseRoutes(
+  transferSvc: TransferService, wastageSvc: WastageService, recSvc: ReconciliationService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Warehouse", "/warehouse", ctx);
+
+  // Transfers
+  r.post("/transfers").summary("Create stock transfer").permission("warehouse:operate")
+    .input(z.object({
+      fromWarehouseId: z.string().uuid(), toWarehouseId: z.string().uuid(), type: z.enum(["requisition", "direct", "return"]).optional(), notes: z.string().optional(),
+      items: z.array(z.object({ entityId: z.string().uuid(), variantId: z.string().uuid().optional(), itemName: z.string(), quantityRequested: z.number().int().positive(), batchNumber: z.string().optional() })).min(1),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as Parameters<typeof transferSvc.create>[1];
+      const result = await transferSvc.create(orgId, { ...body, requestedBy: actor!.userId });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/transfers").summary("List transfers").permission("warehouse:read")
+    .query(z.object({ status: z.string().optional() }))
+    .handler(async ({ query, orgId }) => {
+      const result = await transferSvc.list(orgId, (query as { status?: string }).status);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/transfers/{id}").summary("Get transfer with items").permission("warehouse:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await transferSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/transfers/{id}/approve").summary("Approve transfer").permission("warehouse:admin")
+    .handler(async ({ params, actor, orgId }) => {
+      const result = await transferSvc.approve(orgId, params.id!, actor!.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/transfers/{id}/dispatch").summary("Dispatch transfer").permission("warehouse:operate")
+    .handler(async ({ params, orgId }) => {
+      const result = await transferSvc.dispatch(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/transfers/{id}/receive").summary("Receive transfer").permission("warehouse:operate")
+    .input(z.object({ items: z.array(z.object({ itemId: z.string().uuid(), quantityReceived: z.number().int() })).min(1) }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { items: Array<{ itemId: string; quantityReceived: number }> };
+      const result = await transferSvc.receive(orgId, params.id!, body.items);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // Wastage
+  r.post("/wastage").summary("Create wastage note").permission("warehouse:operate")
+    .input(z.object({
+      warehouseId: z.string().uuid(), type: z.enum(["spoilage", "damage", "expiry", "theft", "prep_waste", "other"]), notes: z.string().optional(),
+      items: z.array(z.object({ entityId: z.string().uuid(), variantId: z.string().uuid().optional(), itemName: z.string(), quantity: z.number().int().positive(), unitCost: z.number().int(), reason: z.string().optional(), batchNumber: z.string().optional() })).min(1),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as Parameters<typeof wastageSvc.create>[1];
+      const result = await wastageSvc.create(orgId, { ...body, recordedBy: actor!.userId });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/wastage").summary("List wastage notes").permission("warehouse:read")
+    .handler(async ({ orgId }) => {
+      const result = await wastageSvc.list(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/wastage/{id}/approve").summary("Approve wastage").permission("warehouse:admin")
+    .handler(async ({ params, actor, orgId }) => {
+      const result = await wastageSvc.approve(orgId, params.id!, actor!.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  // Reconciliation
+  r.post("/reconciliations").summary("Create stock reconciliation").permission("warehouse:operate")
+    .input(z.object({
+      warehouseId: z.string().uuid(),
+      items: z.array(z.object({ entityId: z.string().uuid(), variantId: z.string().uuid().optional(), itemName: z.string(), systemQuantity: z.number().int(), physicalQuantity: z.number().int(), notes: z.string().optional() })).min(1),
+    }))
+    .handler(async ({ input, actor, orgId }) => {
+      const body = input as Parameters<typeof recSvc.create>[1];
+      const result = await recSvc.create(orgId, { ...body, countedBy: actor!.userId });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/reconciliations").summary("List reconciliations").permission("warehouse:read")
+    .handler(async ({ orgId }) => {
+      const result = await recSvc.list(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/reconciliations/{id}").summary("Get reconciliation with items").permission("warehouse:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await recSvc.getById(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/reconciliations/{id}/submit").summary("Submit reconciliation").permission("warehouse:operate")
+    .handler(async ({ params, orgId }) => {
+      const result = await recSvc.submit(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/reconciliations/{id}/approve").summary("Approve reconciliation").permission("warehouse:admin")
+    .handler(async ({ params, actor, orgId }) => {
+      const result = await recSvc.approve(orgId, params.id!, actor!.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,118 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";
+
+export const warehouseBins = pgTable("warehouse_bins", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  warehouseId: uuid("warehouse_id").notNull(),
+  code: text("code").notNull(),
+  name: text("name").notNull(),
+  type: text("type", { enum: ["general", "cold", "frozen", "dry", "hazardous", "display"] }).notNull().default("general"),
+  isActive: boolean("is_active").notNull().default(true),
+  capacity: integer("capacity"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_warehouse_bins_org").on(table.organizationId),
+  codeUnique: uniqueIndex("warehouse_bins_org_wh_code_unique").on(table.organizationId, table.warehouseId, table.code),
+}));
+
+export const stockTransfers = pgTable("stock_transfers", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  transferNumber: text("transfer_number").notNull(),
+  type: text("type", { enum: ["requisition", "direct", "return"] }).notNull().default("requisition"),
+  status: text("status", { enum: ["draft", "pending_approval", "approved", "in_transit", "received", "cancelled"] }).notNull().default("draft"),
+  fromWarehouseId: uuid("from_warehouse_id").notNull(),
+  toWarehouseId: uuid("to_warehouse_id").notNull(),
+  requestedBy: text("requested_by").notNull(),
+  approvedBy: text("approved_by"),
+  dispatchedAt: timestamp("dispatched_at", { withTimezone: true }),
+  receivedAt: timestamp("received_at", { withTimezone: true }),
+  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_stock_transfers_org").on(table.organizationId),
+  statusIdx: index("idx_stock_transfers_status").on(table.status),
+  numUnique: uniqueIndex("stock_transfers_org_num_unique").on(table.organizationId, table.transferNumber),
+}));
+
+export const stockTransferItems = pgTable("stock_transfer_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  transferId: uuid("transfer_id").references(() => stockTransfers.id, { onDelete: "cascade" }).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  itemName: text("item_name").notNull(),
+  quantityRequested: integer("quantity_requested").notNull(),
+  quantityDispatched: integer("quantity_dispatched").notNull().default(0),
+  quantityReceived: integer("quantity_received").notNull().default(0),
+  batchNumber: text("batch_number"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  transferIdx: index("idx_stock_transfer_items_transfer").on(table.transferId),
+}));
+
+export const wastageNotes = pgTable("wastage_notes", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  noteNumber: text("note_number").notNull(),
+  warehouseId: uuid("warehouse_id").notNull(),
+  type: text("type", { enum: ["spoilage", "damage", "expiry", "theft", "prep_waste", "other"] }).notNull(),
+  recordedBy: text("recorded_by").notNull(),
+  approvedBy: text("approved_by"),
+  totalCost: integer("total_cost").notNull().default(0),
+  notes: text("notes"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_wastage_notes_org").on(table.organizationId),
+  numUnique: uniqueIndex("wastage_notes_org_num_unique").on(table.organizationId, table.noteNumber),
+}));
+
+export const wastageNoteItems = pgTable("wastage_note_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  noteId: uuid("note_id").references(() => wastageNotes.id, { onDelete: "cascade" }).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  itemName: text("item_name").notNull(),
+  quantity: integer("quantity").notNull(),
+  unitCost: integer("unit_cost").notNull(),
+  totalCost: integer("total_cost").notNull(),
+  reason: text("reason"),
+  batchNumber: text("batch_number"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  noteIdx: index("idx_wastage_note_items_note").on(table.noteId),
+}));
+
+export const stockReconciliations = pgTable("stock_reconciliations", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  reconciliationNumber: text("reconciliation_number").notNull(),
+  warehouseId: uuid("warehouse_id").notNull(),
+  status: text("status", { enum: ["draft", "counting", "submitted", "approved", "adjusted"] }).notNull().default("draft"),
+  countedBy: text("counted_by").notNull(),
+  approvedBy: text("approved_by"),
+  countedAt: timestamp("counted_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_stock_reconciliations_org").on(table.organizationId),
+  numUnique: uniqueIndex("stock_reconciliations_org_num_unique").on(table.organizationId, table.reconciliationNumber),
+}));
+
+export const reconciliationItems = pgTable("reconciliation_items", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  reconciliationId: uuid("reconciliation_id").references(() => stockReconciliations.id, { onDelete: "cascade" }).notNull(),
+  entityId: uuid("entity_id").notNull(),
+  variantId: uuid("variant_id"),
+  itemName: text("item_name").notNull(),
+  systemQuantity: integer("system_quantity").notNull(),
+  physicalQuantity: integer("physical_quantity").notNull(),
+  variance: integer("variance").notNull(),
+  varianceCost: integer("variance_cost").notNull().default(0),
+  adjustmentMade: boolean("adjustment_made").notNull().default(false),
+  notes: text("notes"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  recIdx: index("idx_reconciliation_items_rec").on(table.reconciliationId),
+}));

package/src/services/reconciliation-service.ts

@@ -0,0 +1,69 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { stockReconciliations, reconciliationItems } from "../schema";
+import type { Db, StockReconciliation, ReconciliationItem } from "../types";
+
+export class ReconciliationService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    warehouseId: string; countedBy: string;
+    items: Array<{ entityId: string; variantId?: string; itemName: string; systemQuantity: number; physicalQuantity: number; notes?: string }>;
+  }): Promise<PluginResult<StockReconciliation>> {
+    const recNumber = await this.generateNumber(orgId);
+    const rows = await this.db.insert(stockReconciliations).values({
+      organizationId: orgId, reconciliationNumber: recNumber,
+      warehouseId: input.warehouseId, countedBy: input.countedBy, countedAt: new Date(),
+    }).returning();
+    const rec = rows[0]!;
+
+    for (const item of input.items) {
+      const variance = item.physicalQuantity - item.systemQuantity;
+      await this.db.insert(reconciliationItems).values({
+        reconciliationId: rec.id, entityId: item.entityId, variantId: item.variantId,
+        itemName: item.itemName, systemQuantity: item.systemQuantity,
+        physicalQuantity: item.physicalQuantity, variance, notes: item.notes,
+      });
+    }
+    return Ok(rec);
+  }
+
+  async list(orgId: string): Promise<PluginResult<StockReconciliation[]>> {
+    return Ok(await this.db.select().from(stockReconciliations).where(eq(stockReconciliations.organizationId, orgId)));
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<{ reconciliation: StockReconciliation; items: ReconciliationItem[] }>> {
+    const rows = await this.db.select().from(stockReconciliations)
+      .where(and(eq(stockReconciliations.id, id), eq(stockReconciliations.organizationId, orgId)));
+    if (rows.length === 0) return Err("Reconciliation not found");
+    const items = await this.db.select().from(reconciliationItems).where(eq(reconciliationItems.reconciliationId, id));
+    return Ok({ reconciliation: rows[0]!, items });
+  }
+
+  async submit(orgId: string, id: string): Promise<PluginResult<StockReconciliation>> {
+    const rows = await this.db.update(stockReconciliations).set({ status: "submitted" })
+      .where(and(eq(stockReconciliations.id, id), eq(stockReconciliations.organizationId, orgId), eq(stockReconciliations.status, "draft"))).returning();
+    if (rows.length === 0) return Err("Not found or not in draft status");
+    return Ok(rows[0]!);
+  }
+
+  async approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<StockReconciliation>> {
+    // Mark items with variance as adjusted
+    const items = await this.db.select().from(reconciliationItems).where(eq(reconciliationItems.reconciliationId, id));
+    for (const item of items) {
+      if (item.variance !== 0) {
+        await this.db.update(reconciliationItems).set({ adjustmentMade: true }).where(eq(reconciliationItems.id, item.id));
+      }
+    }
+    const rows = await this.db.update(stockReconciliations).set({ status: "approved", approvedBy })
+      .where(and(eq(stockReconciliations.id, id), eq(stockReconciliations.organizationId, orgId), eq(stockReconciliations.status, "submitted"))).returning();
+    if (rows.length === 0) return Err("Not found or not in submitted status");
+    return Ok(rows[0]!);
+  }
+
+  private async generateNumber(orgId: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`COUNT(*)`.as("count") }).from(stockReconciliations).where(eq(stockReconciliations.organizationId, orgId));
+    return `REC-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+  }
+}

package/src/services/transfer-service.ts

@@ -0,0 +1,74 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { stockTransfers, stockTransferItems } from "../schema";
+import type { Db, StockTransfer, StockTransferItem } from "../types";
+
+export class TransferService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    fromWarehouseId: string; toWarehouseId: string; requestedBy: string;
+    type?: "requisition" | "direct" | "return"; notes?: string;
+    items: Array<{ entityId: string; variantId?: string; itemName: string; quantityRequested: number; batchNumber?: string }>;
+  }): Promise<PluginResult<StockTransfer>> {
+    if (input.fromWarehouseId === input.toWarehouseId) return Err("Cannot transfer to the same warehouse");
+    const transferNumber = await this.generateNumber(orgId, "TRF");
+    const rows = await this.db.insert(stockTransfers).values({
+      organizationId: orgId, transferNumber, type: input.type ?? "requisition",
+      fromWarehouseId: input.fromWarehouseId, toWarehouseId: input.toWarehouseId,
+      requestedBy: input.requestedBy, notes: input.notes,
+    }).returning();
+    const transfer = rows[0]!;
+    for (const item of input.items) {
+      await this.db.insert(stockTransferItems).values({ transferId: transfer.id, ...item });
+    }
+    return Ok(transfer);
+  }
+
+  async list(orgId: string, status?: string): Promise<PluginResult<StockTransfer[]>> {
+    const conditions = [eq(stockTransfers.organizationId, orgId)];
+    if (status) conditions.push(eq(stockTransfers.status, status as StockTransfer["status"]));
+    return Ok(await this.db.select().from(stockTransfers).where(and(...conditions)));
+  }
+
+  async getById(orgId: string, id: string): Promise<PluginResult<{ transfer: StockTransfer; items: StockTransferItem[] }>> {
+    const rows = await this.db.select().from(stockTransfers).where(and(eq(stockTransfers.id, id), eq(stockTransfers.organizationId, orgId)));
+    if (rows.length === 0) return Err("Transfer not found");
+    const items = await this.db.select().from(stockTransferItems).where(eq(stockTransferItems.transferId, id));
+    return Ok({ transfer: rows[0]!, items });
+  }
+
+  async approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<StockTransfer>> {
+    const rows = await this.db.update(stockTransfers).set({ status: "approved", approvedBy, updatedAt: new Date() })
+      .where(and(eq(stockTransfers.id, id), eq(stockTransfers.organizationId, orgId), eq(stockTransfers.status, "draft"))).returning();
+    if (rows.length === 0) return Err("Transfer not found or not in draft status");
+    return Ok(rows[0]!);
+  }
+
+  async dispatch(orgId: string, id: string): Promise<PluginResult<StockTransfer>> {
+    const items = await this.db.select().from(stockTransferItems).where(eq(stockTransferItems.transferId, id));
+    for (const item of items) {
+      await this.db.update(stockTransferItems).set({ quantityDispatched: item.quantityRequested }).where(eq(stockTransferItems.id, item.id));
+    }
+    const rows = await this.db.update(stockTransfers).set({ status: "in_transit", dispatchedAt: new Date(), updatedAt: new Date() })
+      .where(and(eq(stockTransfers.id, id), eq(stockTransfers.organizationId, orgId), eq(stockTransfers.status, "approved"))).returning();
+    if (rows.length === 0) return Err("Transfer not found or not in approved status");
+    return Ok(rows[0]!);
+  }
+
+  async receive(orgId: string, id: string, receivedItems: Array<{ itemId: string; quantityReceived: number }>): Promise<PluginResult<StockTransfer>> {
+    for (const ri of receivedItems) {
+      await this.db.update(stockTransferItems).set({ quantityReceived: ri.quantityReceived }).where(eq(stockTransferItems.id, ri.itemId));
+    }
+    const rows = await this.db.update(stockTransfers).set({ status: "received", receivedAt: new Date(), updatedAt: new Date() })
+      .where(and(eq(stockTransfers.id, id), eq(stockTransfers.organizationId, orgId), eq(stockTransfers.status, "in_transit"))).returning();
+    if (rows.length === 0) return Err("Transfer not found or not in transit");
+    return Ok(rows[0]!);
+  }
+
+  private async generateNumber(orgId: string, prefix: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`COUNT(*)`.as("count") }).from(stockTransfers).where(eq(stockTransfers.organizationId, orgId));
+    return `${prefix}-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+  }
+}

package/src/services/wastage-service.ts

@@ -0,0 +1,50 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { wastageNotes, wastageNoteItems } from "../schema";
+import type { Db, WastageNote, WastageNoteItem } from "../types";
+
+export class WastageService {
+  constructor(private db: Db) {}
+
+  async create(orgId: string, input: {
+    warehouseId: string; type: "spoilage" | "damage" | "expiry" | "theft" | "prep_waste" | "other";
+    recordedBy: string; notes?: string;
+    items: Array<{ entityId: string; variantId?: string; itemName: string; quantity: number; unitCost: number; reason?: string; batchNumber?: string }>;
+  }): Promise<PluginResult<WastageNote>> {
+    let totalCost = 0;
+    for (const item of input.items) totalCost += item.quantity * item.unitCost;
+
+    const noteNumber = await this.generateNumber(orgId);
+    const rows = await this.db.insert(wastageNotes).values({
+      organizationId: orgId, noteNumber, warehouseId: input.warehouseId,
+      type: input.type, recordedBy: input.recordedBy, totalCost, notes: input.notes,
+    }).returning();
+    const note = rows[0]!;
+
+    for (const item of input.items) {
+      await this.db.insert(wastageNoteItems).values({
+        noteId: note.id, entityId: item.entityId, variantId: item.variantId,
+        itemName: item.itemName, quantity: item.quantity, unitCost: item.unitCost,
+        totalCost: item.quantity * item.unitCost, reason: item.reason, batchNumber: item.batchNumber,
+      });
+    }
+    return Ok(note);
+  }
+
+  async list(orgId: string): Promise<PluginResult<WastageNote[]>> {
+    return Ok(await this.db.select().from(wastageNotes).where(eq(wastageNotes.organizationId, orgId)));
+  }
+
+  async approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<WastageNote>> {
+    const rows = await this.db.update(wastageNotes).set({ approvedBy })
+      .where(and(eq(wastageNotes.id, id), eq(wastageNotes.organizationId, orgId))).returning();
+    if (rows.length === 0) return Err("Wastage note not found");
+    return Ok(rows[0]!);
+  }
+
+  private async generateNumber(orgId: string): Promise<string> {
+    const countRows = await this.db.select({ count: sql<number>`COUNT(*)`.as("count") }).from(wastageNotes).where(eq(wastageNotes.organizationId, orgId));
+    return `WST-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+  }
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+import type { warehouseBins, stockTransfers, stockTransferItems, wastageNotes, wastageNoteItems, stockReconciliations, reconciliationItems } from "./schema";
+export type WarehouseBin = typeof warehouseBins.$inferSelect;
+export type StockTransfer = typeof stockTransfers.$inferSelect;
+export type StockTransferItem = typeof stockTransferItems.$inferSelect;
+export type WastageNote = typeof wastageNotes.$inferSelect;
+export type WastageNoteItem = typeof wastageNoteItems.$inferSelect;
+export type StockReconciliation = typeof stockReconciliations.$inferSelect;
+export type ReconciliationItem = typeof reconciliationItems.$inferSelect;