@unifiedcommerce/plugin-warehouse 0.0.1

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC;AAEJ,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBxB,CAAC;AAEJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AAEJ,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EActB,CAAC;AAEJ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc1B,CAAC;AAEJ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa9B,CAAC;AAEJ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe7B,CAAC"}

package/dist/schema.js

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

@@ -0,0 +1,27 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, StockReconciliation, ReconciliationItem } from "../types";
+export declare class ReconciliationService {
+    private db;
+    constructor(db: Db);
+    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>>;
+    list(orgId: string): Promise<PluginResult<StockReconciliation[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<{
+        reconciliation: StockReconciliation;
+        items: ReconciliationItem[];
+    }>>;
+    submit(orgId: string, id: string): Promise<PluginResult<StockReconciliation>>;
+    approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<StockReconciliation>>;
+    private generateNumber;
+}
+//# sourceMappingURL=reconciliation-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-service.d.ts","sourceRoot":"","sources":["../../src/services/reconciliation-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE5E,qBAAa,qBAAqB;IACpB,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QACvC,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAC;YAAC,gBAAgB,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC5I,GAAG,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;IAmBxC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAIjE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,cAAc,EAAE,mBAAmB,CAAC;QAAC,KAAK,EAAE,kBAAkB,EAAE,CAAA;KAAE,CAAC,CAAC;IAQ/H,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;IAO7E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;YAc1F,cAAc;CAI7B"}

package/dist/services/reconciliation-service.js

@@ -0,0 +1,62 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { stockReconciliations, reconciliationItems } from "../schema";
+export class ReconciliationService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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) {
+        return Ok(await this.db.select().from(stockReconciliations).where(eq(stockReconciliations.organizationId, orgId)));
+    }
+    async getById(orgId, id) {
+        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, id) {
+        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, id, approvedBy) {
+        // 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]);
+    }
+    async generateNumber(orgId) {
+        const countRows = await this.db.select({ count: sql `COUNT(*)`.as("count") }).from(stockReconciliations).where(eq(stockReconciliations.organizationId, orgId));
+        return `REC-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+    }
+}

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

@@ -0,0 +1,33 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, StockTransfer, StockTransferItem } from "../types";
+export declare class TransferService {
+    private db;
+    constructor(db: Db);
+    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>>;
+    list(orgId: string, status?: string): Promise<PluginResult<StockTransfer[]>>;
+    getById(orgId: string, id: string): Promise<PluginResult<{
+        transfer: StockTransfer;
+        items: StockTransferItem[];
+    }>>;
+    approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<StockTransfer>>;
+    dispatch(orgId: string, id: string): Promise<PluginResult<StockTransfer>>;
+    receive(orgId: string, id: string, receivedItems: Array<{
+        itemId: string;
+        quantityReceived: number;
+    }>): Promise<PluginResult<StockTransfer>>;
+    private generateNumber;
+}
+//# sourceMappingURL=transfer-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-service.d.ts","sourceRoot":"","sources":["../../src/services/transfer-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAErE,qBAAa,eAAe;IACd,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QACpE,IAAI,CAAC,EAAE,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAC3D,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,iBAAiB,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC3H,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAelC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;IAM5E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,iBAAiB,EAAE,CAAA;KAAE,CAAC,CAAC;IAOlH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAO5F,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAWzE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;YAUpI,cAAc;CAI7B"}

package/dist/services/transfer-service.js

@@ -0,0 +1,69 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { stockTransfers, stockTransferItems } from "../schema";
+export class TransferService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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, status) {
+        const conditions = [eq(stockTransfers.organizationId, orgId)];
+        if (status)
+            conditions.push(eq(stockTransfers.status, status));
+        return Ok(await this.db.select().from(stockTransfers).where(and(...conditions)));
+    }
+    async getById(orgId, id) {
+        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, id, approvedBy) {
+        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, id) {
+        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, id, receivedItems) {
+        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]);
+    }
+    async generateNumber(orgId, prefix) {
+        const countRows = await this.db.select({ count: sql `COUNT(*)`.as("count") }).from(stockTransfers).where(eq(stockTransfers.organizationId, orgId));
+        return `${prefix}-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { PluginResult } from "@unifiedcommerce/core";
+import type { Db, WastageNote } from "../types";
+export declare class WastageService {
+    private db;
+    constructor(db: Db);
+    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>>;
+    list(orgId: string): Promise<PluginResult<WastageNote[]>>;
+    approve(orgId: string, id: string, approvedBy: string): Promise<PluginResult<WastageNote>>;
+    private generateNumber;
+}
+//# sourceMappingURL=wastage-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wastage-service.d.ts","sourceRoot":"","sources":["../../src/services/wastage-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,EAAE,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAEjE,qBAAa,cAAc;IACb,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACjC,WAAW,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,CAAC;QAC/F,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QACnC,KAAK,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACrJ,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;IAqBhC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IAIzD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;YAOlF,cAAc;CAI7B"}

package/dist/services/wastage-service.js

@@ -0,0 +1,42 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import { wastageNotes, wastageNoteItems } from "../schema";
+export class WastageService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(orgId, input) {
+        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) {
+        return Ok(await this.db.select().from(wastageNotes).where(eq(wastageNotes.organizationId, orgId)));
+    }
+    async approve(orgId, id, approvedBy) {
+        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]);
+    }
+    async generateNumber(orgId) {
+        const countRows = await this.db.select({ count: sql `COUNT(*)`.as("count") }).from(wastageNotes).where(eq(wastageNotes.organizationId, orgId));
+        return `WST-${String(Number(countRows[0]?.count ?? 0) + 1).padStart(4, "0")}`;
+    }
+}