@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/src/generator/generate-seed.ts

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// Static imports of internal module seed data (bundled into CLI)
+import * as primitivesSeed from "../modules/primitives/seed";
+
+type SeedMap = Record<string, Record<string, unknown>>;
+
+// Module name → seed exports. Add new modules here as they gain seed data.
+const INTERNAL_SEED: Record<string, Record<string, unknown>> = {
+  primitives: primitivesSeed,
+};
+
+function mapToJsonl(data: SeedMap): string {
+  return (
+    Object.entries(data)
+      .map(([id, row]) => JSON.stringify({ id, ...row }))
+      .join("\n") + "\n"
+  );
+}
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/**
+ * Checks if a value is a seed data map: Record<string, Record<string, unknown>>.
+ * Distinguishes from ID maps (Record<string, string>) by checking nested values.
+ */
+function isSeedMap(value: unknown): value is SeedMap {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const entries = Object.entries(value as Record<string, unknown>);
+  if (entries.length === 0) return false;
+  return entries.every(([, v]) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+
+export function runGenerateSeed(appPath: string): number {
+  const seedDir = path.join(appPath, "backend", "seed", "data");
+  fs.mkdirSync(seedDir, { recursive: true });
+
+  let written = 0;
+  let skipped = 0;
+  const modulesWithSeed: string[] = [];
+
+  for (const [moduleName, mod] of Object.entries(INTERNAL_SEED)) {
+    const entries = Object.entries(mod).filter(([, v]) => isSeedMap(v)) as [string, SeedMap][];
+    if (entries.length === 0) continue;
+
+    modulesWithSeed.push(moduleName);
+
+    for (const [exportName, data] of entries) {
+      const fileName = capitalize(exportName);
+      const filePath = path.join(seedDir, `${fileName}.jsonl`);
+      if (fs.existsSync(filePath)) {
+        console.log(`  skipped ${fileName}.jsonl (already exists)`);
+        skipped++;
+        continue;
+      }
+      const rowCount = Object.keys(data).length;
+      fs.writeFileSync(filePath, mapToJsonl(data));
+      console.log(`  wrote ${fileName}.jsonl (${rowCount} rows)`);
+      written++;
+    }
+  }
+
+  console.log(`\nModules with seed data: ${modulesWithSeed.join(", ") || "none"}`);
+  console.log(`Generated ${written} file(s), skipped ${skipped} existing`);
+  return 0;
+}

package/src/generator/scaffold.ts

@@ -38,8 +38,12 @@ export function copyTemplateDir(
 
 export function scaffoldModuleBoilerplate(moduleDir: string, moduleName: string): void {
   const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "module");
-  const replacements = { "template-module": moduleName };
-  const placeholderFiles = new Set(["permissions.ts", "tailor.config.ts"]);
+  const erpKitVersion = readErpKitVersion();
+  const replacements = {
+    "template-module": moduleName,
+    '"workspace:*"': `"${erpKitVersion}"`,
+  };
+  const placeholderFiles = new Set(["package.json", "permissions.ts", "tailor.config.ts"]);
   copyTemplateDir(templateDir, moduleDir, replacements, placeholderFiles);
 }
 

package/src/mdschema.ts

@@ -5,18 +5,54 @@ import { createRequire } from "node:module";
 
 const require = createRequire(import.meta.url);
 
+const PLATFORMS: Record<string, Record<string, string>> = {
+  darwin: {
+    arm64: "@jackchuka/mdschema-darwin-arm64",
+    x64: "@jackchuka/mdschema-darwin-x64",
+  },
+  linux: {
+    arm64: "@jackchuka/mdschema-linux-arm64",
+    x64: "@jackchuka/mdschema-linux-x64",
+  },
+  win32: {
+    arm64: "@jackchuka/mdschema-windows-arm64",
+    x64: "@jackchuka/mdschema-windows-x64",
+  },
+};
+
 interface PackageJson {
   bin?: string | Record<string, string>;
 }
 
 export function getMdschemaBin(): string {
   const pkgPath = require.resolve("@jackchuka/mdschema/package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as PackageJson;
-  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
+  const pkgDir = path.dirname(pkgPath);
+
+  // Resolve from mdschema's context so pnpm optionalDependencies are visible
+  const mdschemaRequire = createRequire(pkgPath);
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const pkg = PLATFORMS[process.platform]?.[process.arch];
+  if (pkg) {
+    try {
+      return mdschemaRequire.resolve(`${pkg}/bin/mdschema${ext}`);
+    } catch {
+      // Platform package not installed, fall through
+    }
+  }
+
+  // Fallback: locally downloaded binary from install.js
+  const localBin = path.join(pkgDir, "bin", `mdschema${ext}`);
+  if (fs.existsSync(localBin)) {
+    return localBin;
+  }
+
+  // Last resort: cli.js wrapper (requires shebang support, won't work on Windows)
+  const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as PackageJson;
+  const bin = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.mdschema;
   if (!bin) {
     throw new Error("Could not resolve mdschema binary from package.json bin field");
   }
-  return path.join(path.dirname(pkgPath), bin);
+  return path.join(pkgDir, bin);
 }
 
 export interface MdschemaResult {

package/src/module.ts

@@ -43,3 +43,59 @@ export {
   own as itemManagementOwn,
   all as itemManagementAll,
 } from "./modules/item-management/lib/permissions.generated";
+// audit
+export { defineModule as defineAuditModule } from "./modules/audit/module";
+export {
+  permissions as auditPermissions,
+  own as auditOwn,
+  all as auditAll,
+} from "./modules/audit/lib/permissions.generated";
+// business-partner
+export { defineModule as defineBusinessPartnerModule } from "./modules/business-partner/module";
+export {
+  permissions as businessPartnerPermissions,
+  own as businessPartnerOwn,
+  all as businessPartnerAll,
+} from "./modules/business-partner/lib/permissions.generated";
+// coa-management
+export { defineModule as defineCoaManagementModule } from "./modules/coa-management/module";
+export {
+  permissions as coaManagementPermissions,
+  own as coaManagementOwn,
+  all as coaManagementAll,
+} from "./modules/coa-management/lib/permissions.generated";
+// inventory
+export { defineModule as defineInventoryModule } from "./modules/inventory/module";
+export {
+  permissions as inventoryPermissions,
+  own as inventoryOwn,
+  all as inventoryAll,
+} from "./modules/inventory/lib/permissions.generated";
+// organization
+export { defineModule as defineOrganizationModule } from "./modules/organization/module";
+export {
+  permissions as organizationPermissions,
+  own as organizationOwn,
+  all as organizationAll,
+} from "./modules/organization/lib/permissions.generated";
+// product-management
+export { defineModule as defineProductManagementModule } from "./modules/product-management/module";
+export {
+  permissions as productManagementPermissions,
+  own as productManagementOwn,
+  all as productManagementAll,
+} from "./modules/product-management/lib/permissions.generated";
+// purchase
+export { defineModule as definePurchaseModule } from "./modules/purchase/module";
+export {
+  permissions as purchasePermissions,
+  own as purchaseOwn,
+  all as purchaseAll,
+} from "./modules/purchase/lib/permissions.generated";
+// sales
+export { defineModule as defineSalesModule } from "./modules/sales/module";
+export {
+  permissions as salesPermissions,
+  own as salesOwn,
+  all as salesAll,
+} from "./modules/sales/lib/permissions.generated";

package/src/modules/business-partner/README.md

@@ -36,7 +36,7 @@ Partners serve as the authoritative counterparty reference for all downstream tr
 - Supplier onboarding workflows with approval gates (`purchase` module)
 - Supplier qualification, certification, and performance scoring (`purchase` module)
 - Supplier catalog — linking suppliers to items they supply (`purchase` module)
-- Payment terms and pricing rules (`payment-terms` module)
+- Payment term and pricing rule definitions (`purchase` module); business-partner may still expose supplier defaults or references consumed by purchase
 - Duplicate detection and automated merge (future enhancement)
 - Partner portal and self-service capabilities (future enhancement)
 - Activity logging — calls, emails, meetings, notes (CRM module)
@@ -52,7 +52,7 @@ Addresses are included here rather than in the organization module because partn
 
 Contact persons are included because knowing who to communicate with at a partner organization is core master data, not a CRM concern. However, activity tracking (logging calls, meetings, emails) is excluded as CRM functionality.
 
-Supplier catalog (which suppliers provide which items), payment terms, and pricing are excluded because they involve transactional business rules that change at different rates than partner master data. A supplier catalog naturally fits in a purchasing module where it integrates with PO workflows. Payment terms belong in pricing/accounting where they interact with discount rules and installment plans.
+Supplier catalog (which suppliers provide which items), payment term definitions, and pricing are excluded because they involve transactional business rules that change at different rates than partner master data. A supplier catalog naturally fits in the purchase module where it integrates with PO workflows. Purchase also owns payment-term and pricing definitions because they directly drive supplier-facing procurement documents, while business-partner may only expose supplier defaults or references that purchase consumes.
 
 ## Module Dependencies
 

package/src/modules/inventory/README.md

@@ -0,0 +1,65 @@
+# README
+
+## Overview
+
+The Inventory module manages physical stock tracking across warehouses and storage locations. It provides real-time visibility into on-hand quantities, records all stock movements (receipts, issues, transfers, adjustments), and supports lot/batch and serial number traceability. The module also handles inventory valuation, physical inventory counts, and scrap disposal.
+
+Inventory operates at the Item level (from item-management) and tracks stock within Warehouses and StorageLocations that the module owns. Organization's Site entity represents the physical facility; Inventory's Warehouse represents the operational storage structure within a Site.
+
+## Key Features
+
+- **Warehouse Management**: Define warehouses and storage locations (zones, bins) within organizational sites
+- **Stock Tracking**: Real-time on-hand, reserved, incoming, and blocked quantities per item per location
+- **Stock Movement**: Record goods receipts, goods issues, and internal transfers with full audit trail
+- **Inventory Adjustment**: Manual corrections for discrepancies, damage, and shrinkage
+- **Lot and Batch Tracking**: Lot/batch-level traceability with expiration date management
+- **Serial Number Tracking**: Individual item tracking by unique serial number across lifecycle
+- **Inventory Valuation**: Cost calculation using FIFO, weighted average, or standard cost methods
+- **Inventory Count**: Physical inventory counts and cycle counts with variance review and approval
+- **Scrap Management**: Record and track disposal of damaged, expired, or defective stock
+
+## Module Scope
+
+### In Scope
+
+- Warehouse and storage location (zone/bin) definition and management
+- Real-time stock level tracking per item per location (on-hand, reserved, incoming, blocked)
+- Stock movement recording: goods receipt, goods issue, internal transfer
+- Inventory adjustment with reason codes
+- Lot/batch assignment, tracking, and expiration date management
+- Serial number assignment and lifecycle tracking
+- Inventory valuation method configuration (FIFO, weighted average, standard cost)
+- Cost-per-unit tracking and valuation amount calculation
+- Physical inventory count and cycle count workflows
+- Scrap/disposal recording with quantity and valuation impact
+
+### Out of Scope
+
+- Purchase order lifecycle management (purchasing module)
+- Sales order and fulfillment workflows (sales module)
+- Automated reorder point and replenishment rules (purchasing module)
+- Pick/pack/ship multi-step fulfillment (warehouse operations / sales module)
+- Putaway rules and automated storage location assignment
+- Removal strategies — automated FIFO/FEFO/LIFO picking rules
+- Demand forecasting and planning
+- Drop-shipping and cross-docking
+- Landed cost allocation (purchasing / accounting module)
+- Journal entry posting to general ledger (accounting module)
+- Barcode scanning device integration (application layer)
+- Shipping carrier integration (application layer)
+
+### Scope Decision Rationale
+
+Inventory owns **physical stock state** — where items are, how many exist, and what they cost. This is separated from purchasing (which owns the procurement lifecycle) and sales (which owns the fulfillment lifecycle) because stock tracking follows its own business rules and update patterns.
+
+Warehouse and StorageLocation are owned by this module (not organization) because they represent operational storage structures with inventory-specific attributes (capacity, storage conditions, bin types). Organization's Site represents the physical facility identity and address; Warehouse adds the storage layout within that facility.
+
+Lot/batch and serial number tracking live here (not in item-management) because they are inventory-layer concepts — they track "which specific instances" of an item exist, not "what the item is." Item-management explicitly defers these concerns to the inventory module.
+
+Inventory valuation is included because cost-per-unit is intrinsically tied to stock movements (receipt costs, adjustment impacts). However, posting journal entries to the general ledger is excluded — that responsibility belongs to a future accounting module. Inventory will emit valuation events for downstream consumption.
+
+## Module Dependencies
+
+- [item-management](../item-management/README.md) — Item entity as the primary trackable unit (itemId/SKU)
+- [organization](../organization/README.md) — Company for multi-company scoping, Site for warehouse location
+- [primitives](../primitives/README.md) — Unit of Measure for stock quantities, Currency for valuation amounts

package/src/modules/inventory/command/approveCountLine.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./approveCountLine";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const approveCountLine = defineCommand(permissions.approveCountLine, run);

package/src/modules/inventory/command/approveCountLine.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CountLineNotFoundError, CountLineNotPendingError } from "../lib/errors.generated";
+import { basePendingCountLine, baseApprovedCountLine } from "../testing/fixtures";
+import { run } from "./approveCountLine";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("approveCountLine", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:approveCountLine"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // line not found
+
+    const result = await run(db, { countLineId: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineNotFoundError);
+    }
+  });
+
+  it("returns error when not pending", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseApprovedCountLine); // already APPROVED
+
+    const result = await run(db, { countLineId: "count-line-2" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineNotPendingError);
+    }
+  });
+
+  it("approves line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const approvedLine = { ...basePendingCountLine, status: "APPROVED" };
+
+    spies.select.mockReturnValueOnce(basePendingCountLine); // line lookup
+    spies.update.mockReturnValue(approvedLine);
+    spies.insert.mockReturnValue({ id: "adjustment-new" }); // adjustment created
+
+    const result = await run(db, { countLineId: "count-line-1" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("APPROVED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("generates adjustment for non-zero variance", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // basePendingCountLine has variance: -2
+    const approvedLine = { ...basePendingCountLine, status: "APPROVED" };
+
+    spies.select.mockReturnValueOnce(basePendingCountLine);
+    spies.update.mockReturnValue(approvedLine);
+    spies.insert.mockReturnValue({ id: "adjustment-new" });
+
+    const result = await run(db, { countLineId: "count-line-1" }, ctx);
+    expect(result.ok).toBe(true);
+    expect(spies.insert).toHaveBeenCalled();
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reasonCode: "inventory-count",
+        quantityDelta: -2,
+      }),
+    );
+  });
+
+  it("zero variance approved without adjustment", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const zeroVarianceLine = { ...basePendingCountLine, variance: 0 };
+    const approvedLine = { ...zeroVarianceLine, status: "APPROVED" };
+
+    spies.select.mockReturnValueOnce(zeroVarianceLine);
+    spies.update.mockReturnValue(approvedLine);
+
+    const result = await run(db, { countLineId: "count-line-1" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("APPROVED");
+    }
+    // No insert should have been called for adjustment
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+});

package/src/modules/inventory/command/approveCountLine.ts

@@ -0,0 +1,68 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CountLineNotFoundError, CountLineNotPendingError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ApproveCountLineInput {
+  countLineId: string;
+}
+
+/**
+ * Function: approveCountLine
+ *
+ * Approves a count line variance, transitioning it from PENDING to APPROVED.
+ * When variance is non-zero, generates an inventory adjustment with reason "inventory-count".
+ */
+export async function run(db: Transaction, input: ApproveCountLineInput, _ctx: CommandContext) {
+  const { countLineId } = input;
+
+  // 1. Fetch count line
+  const countLine = await db
+    .selectFrom("InventoryCountLine")
+    .selectAll()
+    .where("id", "=", countLineId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!countLine) {
+    return err(new CountLineNotFoundError(countLineId));
+  }
+
+  // 2. Validate status
+  if (countLine.status !== "PENDING") {
+    return err(new CountLineNotPendingError(countLineId));
+  }
+
+  // 3. Approve the line
+  const updatedLine = await db
+    .updateTable("InventoryCountLine")
+    .set({
+      status: "APPROVED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", countLineId)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 4. Generate adjustment if variance is non-zero
+  if (countLine.variance !== 0 && countLine.variance !== null) {
+    await db
+      .insertInto("InventoryAdjustment")
+      .values({
+        adjustmentType: "CORRECTION",
+        itemId: countLine.itemId,
+        storageLocationId: countLine.storageLocationId,
+        quantityDelta: countLine.variance,
+        reasonCode: "inventory-count",
+        status: "APPROVED",
+        inventoryCountId: countLine.inventoryCountId,
+        lotId: null,
+        serialNumberId: null,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  return ok({ countLine: updatedLine! });
+}

package/src/modules/inventory/command/approveInventoryAdjustment.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./approveInventoryAdjustment";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const approveInventoryAdjustment = defineCommand(permissions.approveInventoryAdjustment, run);

package/src/modules/inventory/command/approveInventoryAdjustment.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentNotPendingApprovalError,
+} from "../lib/errors.generated";
+import { basePendingApprovalAdjustment, baseDraftAdjustment } from "../testing/fixtures";
+import { run } from "./approveInventoryAdjustment";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("approveInventoryAdjustment", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:approveInventoryAdjustment"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentNotFoundError);
+    }
+  });
+
+  it("returns error when not pending", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftAdjustment);
+
+    const result = await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentNotPendingApprovalError);
+    }
+  });
+
+  it("approves adjustment", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...basePendingApprovalAdjustment, status: "APPROVED" };
+    spies.select.mockReturnValueOnce(basePendingApprovalAdjustment);
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, { id: "adjustment-2" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("APPROVED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/inventory/command/approveInventoryAdjustment.ts

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentNotPendingApprovalError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ApproveInventoryAdjustmentInput {
+  id: string;
+}
+
+/**
+ * Function: approveInventoryAdjustment
+ *
+ * Approves a pending inventory adjustment, transitioning it from PENDING_APPROVAL to APPROVED status.
+ */
+export async function run(
+  db: Transaction,
+  input: ApproveInventoryAdjustmentInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Fetch adjustment
+  const adjustment = await db
+    .selectFrom("InventoryAdjustment")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!adjustment) {
+    return err(new AdjustmentNotFoundError(id));
+  }
+
+  // 2. Validate status is PENDING_APPROVAL
+  if (adjustment.status !== "PENDING_APPROVAL") {
+    return err(new AdjustmentNotPendingApprovalError(id));
+  }
+
+  // 3. Update status to APPROVED
+  const updated = await db
+    .updateTable("InventoryAdjustment")
+    .set({ status: "APPROVED", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ adjustment: updated! });
+}

package/src/modules/inventory/command/assignSerialNumber.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./assignSerialNumber";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const assignSerialNumber = defineCommand(permissions.assignSerialNumber, run);