@tailor-platform/erp-kit 0.4.1 → 0.5.0

package/src/modules/inventory/query/getStockLevel.ts

@@ -0,0 +1,24 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetStockLevelInput {
+  itemId: string;
+  storageLocationId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetStockLevelInput) {
+  const stockLevel = await db
+    .selectFrom("StockLevel")
+    .selectAll()
+    .where("itemId", "=", input.itemId)
+    .where("storageLocationId", "=", input.storageLocationId)
+    .executeTakeFirst();
+
+  if (!stockLevel) {
+    return ok({ stockLevel: null });
+  }
+
+  const availableQuantity = stockLevel.onHand - stockLevel.reserved - stockLevel.blocked;
+
+  return ok({ stockLevel: { ...stockLevel, availableQuantity } });
+}

package/src/modules/inventory/query/getStockMovement.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getStockMovement";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getStockMovement = defineQuery(run);

package/src/modules/inventory/query/getStockMovement.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseDraftMovement, baseMoveLine } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getStockMovement";
+
+describe("getStockMovement", () => {
+  it("returns stock movement when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.select.mockReturnValueOnce([baseMoveLine]);
+
+    const result = await run(db, { id: baseDraftMovement.id });
+    const { stockMovement } = expectOk<{ stockMovement: unknown }>(result as never);
+
+    expect(stockMovement).not.toBeNull();
+    expect(stockMovement).toMatchObject({ id: baseDraftMovement.id });
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { stockMovement, stockMoveLines } = expectOk<{
+      stockMovement: unknown;
+      stockMoveLines: unknown[];
+    }>(result as never);
+
+    expect(stockMovement).toBeNull();
+    expect(stockMoveLines).toEqual([]);
+  });
+
+  it("includes all movement lines", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.select.mockReturnValueOnce([baseMoveLine]);
+
+    const result = await run(db, { id: baseDraftMovement.id });
+    const { stockMoveLines } = expectOk<{ stockMoveLines: unknown[] }>(result as never);
+
+    expect(stockMoveLines).toHaveLength(1);
+  });
+
+  it("includes source and destination locations per line", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.select.mockReturnValueOnce([baseMoveLine]);
+
+    const result = await run(db, { id: baseDraftMovement.id });
+    const { stockMoveLines } = expectOk<{
+      stockMoveLines: {
+        sourceLocationId: string | null;
+        destinationLocationId: string | null;
+      }[];
+    }>(result as never);
+
+    expect(stockMoveLines[0].sourceLocationId).toBeNull();
+    expect(stockMoveLines[0].destinationLocationId).toBe("location-1");
+  });
+});

package/src/modules/inventory/query/getStockMovement.ts

@@ -0,0 +1,26 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetStockMovementInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetStockMovementInput) {
+  const stockMovement = await db
+    .selectFrom("StockMovement")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!stockMovement) {
+    return ok({ stockMovement: null, stockMoveLines: [] });
+  }
+
+  const stockMoveLines = await db
+    .selectFrom("StockMoveLine")
+    .selectAll()
+    .where("stockMovementId", "=", stockMovement.id)
+    .execute();
+
+  return ok({ stockMovement, stockMoveLines });
+}

package/src/modules/inventory/query/getStorageLocation.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getStorageLocation";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getStorageLocation = defineQuery(run);

package/src/modules/inventory/query/getStorageLocation.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseZone, baseBin, baseStockLevel } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getStorageLocation";
+
+describe("getStorageLocation", () => {
+  it("returns storage location when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseZone);
+    spies.select.mockReturnValueOnce([baseStockLevel]);
+
+    const result = await run(db, { id: baseZone.id });
+    const { storageLocation } = expectOk<{ storageLocation: unknown }>(result as never);
+
+    expect(storageLocation).not.toBeNull();
+    expect(storageLocation).toMatchObject({ id: baseZone.id });
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { storageLocation } = expectOk<{ storageLocation: unknown }>(result as never);
+
+    expect(storageLocation).toBeNull();
+  });
+
+  it("includes associated stock levels", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseZone);
+    spies.select.mockReturnValueOnce([baseStockLevel]);
+
+    const result = await run(db, { id: baseZone.id });
+    const { stockLevels } = expectOk<{ stockLevels: unknown[] }>(result as never);
+
+    expect(stockLevels).toHaveLength(1);
+  });
+
+  it("includes parent zone reference for bins", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseBin);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseBin.id });
+    const { storageLocation } = expectOk<{
+      storageLocation: { parentId: string };
+    }>(result as never);
+
+    expect(storageLocation.parentId).toBe("location-1");
+  });
+});

package/src/modules/inventory/query/getStorageLocation.ts

@@ -0,0 +1,26 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetStorageLocationInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetStorageLocationInput) {
+  const storageLocation = await db
+    .selectFrom("StorageLocation")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!storageLocation) {
+    return ok({ storageLocation: null, stockLevels: [] });
+  }
+
+  const stockLevels = await db
+    .selectFrom("StockLevel")
+    .selectAll()
+    .where("storageLocationId", "=", storageLocation.id)
+    .execute();
+
+  return ok({ storageLocation, stockLevels });
+}

package/src/modules/inventory/query/getValuationPolicy.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getValuationPolicy";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getValuationPolicy = defineQuery(run);

package/src/modules/inventory/query/getValuationPolicy.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseFifoPolicy, baseStandardCostPolicy } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getValuationPolicy";
+
+describe("getValuationPolicy", () => {
+  it("returns valuation policy when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseFifoPolicy);
+
+    const result = await run(db, { id: baseFifoPolicy.id });
+    const { valuationPolicy } = expectOk<{ valuationPolicy: unknown }>(result as never);
+
+    expect(valuationPolicy).not.toBeNull();
+    expect(valuationPolicy).toMatchObject({ id: baseFifoPolicy.id });
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { valuationPolicy } = expectOk<{ valuationPolicy: unknown }>(result as never);
+
+    expect(valuationPolicy).toBeNull();
+  });
+
+  it("includes costing method and standard cost rate", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseStandardCostPolicy);
+
+    const result = await run(db, { id: baseStandardCostPolicy.id });
+    const { valuationPolicy } = expectOk<{
+      valuationPolicy: { costingMethod: string; standardCostRate: number };
+    }>(result as never);
+
+    expect(valuationPolicy.costingMethod).toBe("STANDARD_COST");
+    expect(valuationPolicy.standardCostRate).toBe(10.5);
+  });
+});

package/src/modules/inventory/query/getValuationPolicy.ts

@@ -0,0 +1,16 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetValuationPolicyInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetValuationPolicyInput) {
+  const valuationPolicy = await db
+    .selectFrom("ValuationPolicy")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ valuationPolicy: valuationPolicy ?? null });
+}

package/src/modules/inventory/query/getWarehouse.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getWarehouse";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getWarehouse = defineQuery(run);

package/src/modules/inventory/query/getWarehouse.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveWarehouse, baseInactiveWarehouse, baseZone, baseBin } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getWarehouse";
+
+describe("getWarehouse", () => {
+  it("returns warehouse when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([baseZone]);
+
+    const result = await run(db, { id: baseActiveWarehouse.id });
+    const { warehouse } = expectOk<{ warehouse: unknown }>(result as never);
+
+    expect(warehouse).not.toBeNull();
+    expect(warehouse).toMatchObject({ id: baseActiveWarehouse.id });
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { warehouse, storageLocations } = expectOk<{
+      warehouse: unknown;
+      storageLocations: unknown[];
+    }>(result as never);
+
+    expect(warehouse).toBeNull();
+    expect(storageLocations).toEqual([]);
+  });
+
+  it("includes associated storage locations", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([baseZone, baseBin]);
+
+    const result = await run(db, { id: baseActiveWarehouse.id });
+    const { storageLocations } = expectOk<{
+      storageLocations: unknown[];
+    }>(result as never);
+
+    expect(storageLocations).toHaveLength(2);
+  });
+
+  it("includes storage condition and capacity", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveWarehouse);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { id: baseInactiveWarehouse.id });
+    const { warehouse } = expectOk<{
+      warehouse: { storageCondition: string; capacity: number };
+    }>(result as never);
+
+    expect(warehouse.storageCondition).toBe("cold");
+    expect(warehouse.capacity).toBe(5000);
+  });
+});

package/src/modules/inventory/query/getWarehouse.ts

@@ -0,0 +1,26 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetWarehouseInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetWarehouseInput) {
+  const warehouse = await db
+    .selectFrom("Warehouse")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  if (!warehouse) {
+    return ok({ warehouse: null, storageLocations: [] });
+  }
+
+  const storageLocations = await db
+    .selectFrom("StorageLocation")
+    .selectAll()
+    .where("warehouseId", "=", warehouse.id)
+    .execute();
+
+  return ok({ warehouse, storageLocations });
+}

package/src/modules/inventory/query/getWarehouseStockSummary.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getWarehouseStockSummary";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getWarehouseStockSummary = defineQuery(run);

package/src/modules/inventory/query/getWarehouseStockSummary.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveWarehouse, baseStockLevel } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { WarehouseNotFoundError } from "../lib/errors.generated";
+import { run } from "./getWarehouseStockSummary";
+
+describe("getWarehouseStockSummary", () => {
+  it("returns aggregated quantities per item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([{ id: "location-1" }]);
+    spies.select.mockReturnValueOnce([baseStockLevel]);
+
+    const result = await run(db, { warehouseId: baseActiveWarehouse.id });
+    const { summary } = expectOk<{
+      summary: { itemId: string; totalOnHand: number }[];
+    }>(result as never);
+
+    expect(summary).toHaveLength(1);
+    expect(summary[0].totalOnHand).toBe(100);
+  });
+
+  it("correctly sums across multiple locations", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([{ id: "location-1" }, { id: "location-2" }]);
+    spies.select.mockReturnValueOnce([
+      baseStockLevel,
+      {
+        ...baseStockLevel,
+        id: "stock-level-2",
+        storageLocationId: "location-2",
+        onHand: 50,
+        reserved: 5,
+        incoming: 10,
+        blocked: 0,
+      },
+    ]);
+
+    const result = await run(db, { warehouseId: baseActiveWarehouse.id });
+    const { summary } = expectOk<{
+      summary: {
+        itemId: string;
+        totalOnHand: number;
+        totalReserved: number;
+        totalIncoming: number;
+        totalBlocked: number;
+        totalAvailable: number;
+      }[];
+    }>(result as never);
+
+    expect(summary).toHaveLength(1);
+    expect(summary[0].totalOnHand).toBe(150);
+    expect(summary[0].totalReserved).toBe(15);
+    expect(summary[0].totalIncoming).toBe(30);
+    expect(summary[0].totalBlocked).toBe(5);
+  });
+
+  it("filters by item when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([{ id: "location-1" }]);
+    spies.select.mockReturnValueOnce([baseStockLevel]);
+
+    const result = await run(db, {
+      warehouseId: baseActiveWarehouse.id,
+      itemId: "item-1",
+    });
+    const { summary } = expectOk<{
+      summary: { itemId: string; totalOnHand: number }[];
+    }>(result as never);
+
+    expect(summary).toHaveLength(1);
+    expect(summary[0].itemId).toBe("item-1");
+  });
+
+  it("returns error when warehouse not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { warehouseId: "nonexistent-warehouse" });
+    expectErr(result as never, WarehouseNotFoundError);
+  });
+
+  it("excludes inactive storage locations", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { warehouseId: baseActiveWarehouse.id });
+    const { summary } = expectOk<{ summary: unknown[] }>(result as never);
+
+    expect(summary).toEqual([]);
+  });
+});

package/src/modules/inventory/query/getWarehouseStockSummary.ts

@@ -0,0 +1,82 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { WarehouseNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetWarehouseStockSummaryInput {
+  warehouseId: string;
+  itemId?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetWarehouseStockSummaryInput) {
+  const warehouse = await db
+    .selectFrom("Warehouse")
+    .selectAll()
+    .where("id", "=", input.warehouseId)
+    .executeTakeFirst();
+
+  if (!warehouse) {
+    return err(new WarehouseNotFoundError(input.warehouseId));
+  }
+
+  const activeLocationIds = await db
+    .selectFrom("StorageLocation")
+    .select("id")
+    .where("warehouseId", "=", input.warehouseId)
+    .where("status", "=", "ACTIVE")
+    .execute();
+
+  if (activeLocationIds.length === 0) {
+    return ok({ summary: [] });
+  }
+
+  const locationIds = activeLocationIds.map((loc) => loc.id);
+
+  let query = db
+    .selectFrom("StockLevel")
+    .select("itemId")
+    .where("storageLocationId", "in", locationIds);
+
+  if (input.itemId) {
+    query = query.where("itemId", "=", input.itemId);
+  }
+
+  const stockLevels = await query.selectAll().execute();
+
+  // Aggregate in-memory grouped by itemId
+  const grouped = new Map<
+    string,
+    {
+      itemId: string;
+      totalOnHand: number;
+      totalReserved: number;
+      totalIncoming: number;
+      totalBlocked: number;
+      totalAvailable: number;
+    }
+  >();
+
+  for (const sl of stockLevels) {
+    const existing = grouped.get(sl.itemId);
+    const available = sl.onHand - sl.reserved - sl.blocked;
+    if (existing) {
+      existing.totalOnHand += sl.onHand;
+      existing.totalReserved += sl.reserved;
+      existing.totalIncoming += sl.incoming;
+      existing.totalBlocked += sl.blocked;
+      existing.totalAvailable += available;
+    } else {
+      grouped.set(sl.itemId, {
+        itemId: sl.itemId,
+        totalOnHand: sl.onHand,
+        totalReserved: sl.reserved,
+        totalIncoming: sl.incoming,
+        totalBlocked: sl.blocked,
+        totalAvailable: available,
+      });
+    }
+  }
+
+  const summary = Array.from(grouped.values());
+
+  return ok({ summary });
+}

package/src/modules/inventory/query/listCostLayers.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./listCostLayers";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const listCostLayers = defineQuery(run);

package/src/modules/inventory/query/listCostLayers.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseCostLayer } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./listCostLayers";
+
+describe("listCostLayers", () => {
+  it("lists cost layers by item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostLayer]);
+
+    const result = await run(db, { itemId: "item-1" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("lists cost layers by valuation policy", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostLayer]);
+
+    const result = await run(db, { valuationPolicyId: "policy-1" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("lists cost layers by both item and valuation policy", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostLayer]);
+
+    const result = await run(db, { itemId: "item-1", valuationPolicyId: "policy-1" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns results in oldest-first order", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseCostLayer]);
+
+    const result = await run(db, { itemId: "item-1" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("returns empty list when no matches", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { itemId: "non-existent" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+});

package/src/modules/inventory/query/listCostLayers.ts

@@ -0,0 +1,45 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { NoFilterProvidedError } from "../lib/errors.generated";
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "createdAt";
+
+export interface ListCostLayersInput extends PaginationInput<OrderByField> {
+  itemId?: string;
+  valuationPolicyId?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListCostLayersInput) {
+  if (!input.itemId && !input.valuationPolicyId) {
+    return err(new NoFilterProvidedError("listCostLayers"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "createdAt";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("CostLayer").selectAll();
+
+  if (input.itemId) {
+    query = query.where("itemId", "=", input.itemId);
+  }
+  if (input.valuationPolicyId) {
+    query = query.where("valuationPolicyId", "=", input.valuationPolicyId);
+  }
+
+  const costLayers = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(costLayers, limit));
+}

package/src/modules/inventory/query/listExpiringLots.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./listExpiringLots";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const listExpiringLots = defineQuery(run);