@tailor-platform/erp-kit 0.4.1 → 0.5.1

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

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

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

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseFifoPolicy, baseAvcoPolicy } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./listValuationPolicies";
+
+describe("listValuationPolicies", () => {
+  it("lists all valuation policies", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseFifoPolicy, baseAvcoPolicy]);
+
+    const result = await run(db, {});
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters by costing method", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseFifoPolicy]);
+
+    const result = await run(db, { costingMethod: "FIFO" });
+    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, { costingMethod: "FIFO" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "name" | "createdAt";
+
+export interface ListValuationPoliciesInput extends PaginationInput<OrderByField> {
+  costingMethod?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListValuationPoliciesInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "name";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("ValuationPolicy").selectAll();
+
+  if (input.costingMethod) {
+    query = query.where(
+      "costingMethod",
+      "=",
+      input.costingMethod as "FIFO" | "AVCO" | "STANDARD_COST",
+    );
+  }
+
+  const valuationPolicies = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(valuationPolicies, limit));
+}

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

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

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveWarehouse, baseInactiveWarehouse } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./listWarehouses";
+
+describe("listWarehouses", () => {
+  it("lists warehouses by site", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWarehouse]);
+
+    const result = await run(db, { siteId: "site-1" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("lists warehouses by status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWarehouse]);
+
+    const result = await run(db, { status: "ACTIVE" });
+    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, { siteId: "non-existent" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(0);
+  });
+
+  it("orders by name ascending", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWarehouse, baseInactiveWarehouse]);
+
+    const result = await run(db, {});
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("does not include storage locations", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseActiveWarehouse]);
+
+    const result = await run(db, { siteId: "site-1" });
+    const { items } = expectOk<{ items: Record<string, unknown>[]; hasNextPage: boolean }>(
+      result as never,
+    );
+
+    expect(items[0]).not.toHaveProperty("storageLocations");
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "name" | "createdAt";
+
+export interface ListWarehousesInput extends PaginationInput<OrderByField> {
+  siteId?: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListWarehousesInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "name";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("Warehouse").selectAll();
+
+  if (input.siteId) {
+    query = query.where("siteId", "=", input.siteId);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as "ACTIVE" | "INACTIVE");
+  }
+
+  const warehouses = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(warehouses, limit));
+}

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

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

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

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveLot, baseMoveLine } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { LotNotFoundError } from "../lib/errors.generated";
+import { run } from "./traceLotBackward";
+
+const receiptMoveLine = {
+  ...baseMoveLine,
+  lotId: "lot-1",
+  movementType: "GOODS_RECEIPT",
+  executedAt: new Date("2024-01-02T00:00:00.000Z"),
+  status: "DONE",
+  reasonCode: null,
+};
+
+describe("traceLotBackward", () => {
+  it("returns inbound movements for lot", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([receiptMoveLine]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{ moveLines: unknown[] }>(result as never);
+
+    expect(moveLines).toHaveLength(1);
+  });
+
+  it("includes movement date and source reference", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([receiptMoveLine]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{
+      moveLines: { executedAt: Date; reasonCode: string | null }[];
+    }>(result as never);
+
+    expect(moveLines[0].executedAt).toEqual(new Date("2024-01-02T00:00:00.000Z"));
+    expect(moveLines[0].reasonCode).toBeNull();
+  });
+
+  it("returns error when lot not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { lotId: "non-existent" });
+
+    expectErr(result as never, LotNotFoundError);
+  });
+
+  it("returns empty list when no receipt found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{ moveLines: unknown[] }>(result as never);
+
+    expect(moveLines).toEqual([]);
+  });
+});

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

@@ -0,0 +1,36 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { LotNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface TraceLotBackwardInput {
+  lotId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: TraceLotBackwardInput) {
+  const lot = await db
+    .selectFrom("Lot")
+    .selectAll()
+    .where("id", "=", input.lotId)
+    .executeTakeFirst();
+
+  if (!lot) {
+    return err(new LotNotFoundError(input.lotId));
+  }
+
+  const moveLines = await db
+    .selectFrom("StockMoveLine")
+    .innerJoin("StockMovement", "StockMovement.id", "StockMoveLine.stockMovementId")
+    .selectAll("StockMoveLine")
+    .select([
+      "StockMovement.movementType",
+      "StockMovement.executedAt",
+      "StockMovement.status",
+      "StockMovement.reasonCode",
+    ])
+    .where("StockMoveLine.lotId", "=", input.lotId)
+    .where("StockMovement.movementType", "=", "GOODS_RECEIPT")
+    .orderBy("StockMoveLine.createdAt", "asc")
+    .execute();
+
+  return ok({ moveLines });
+}

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

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

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

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveLot, baseMoveLine } from "../testing/fixtures";
+import { expectOk, expectErr } from "../testing/commandTestUtils";
+import { LotNotFoundError } from "../lib/errors.generated";
+import { run } from "./traceLotForward";
+
+const issueMoveLine = {
+  ...baseMoveLine,
+  lotId: "lot-1",
+  movementType: "GOODS_ISSUE",
+  executedAt: new Date("2024-01-02T00:00:00.000Z"),
+  status: "DONE",
+  reasonCode: null,
+};
+
+describe("traceLotForward", () => {
+  it("returns outbound movements for lot", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([issueMoveLine]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{ moveLines: unknown[] }>(result as never);
+
+    expect(moveLines).toHaveLength(1);
+  });
+
+  it("includes movement date and destination", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([issueMoveLine]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{
+      moveLines: { executedAt: Date; destinationLocationId: string | null }[];
+    }>(result as never);
+
+    expect(moveLines[0].executedAt).toEqual(new Date("2024-01-02T00:00:00.000Z"));
+    expect(moveLines[0].destinationLocationId).toBe("location-1");
+  });
+
+  it("returns error when lot not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { lotId: "non-existent" });
+
+    expectErr(result as never, LotNotFoundError);
+  });
+
+  it("returns empty list when lot has no outbound movements", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveLot);
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { lotId: "lot-1" });
+    const { moveLines } = expectOk<{ moveLines: unknown[] }>(result as never);
+
+    expect(moveLines).toEqual([]);
+  });
+});

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

@@ -0,0 +1,36 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { LotNotFoundError } from "../lib/errors.generated";
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface TraceLotForwardInput {
+  lotId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: TraceLotForwardInput) {
+  const lot = await db
+    .selectFrom("Lot")
+    .selectAll()
+    .where("id", "=", input.lotId)
+    .executeTakeFirst();
+
+  if (!lot) {
+    return err(new LotNotFoundError(input.lotId));
+  }
+
+  const moveLines = await db
+    .selectFrom("StockMoveLine")
+    .innerJoin("StockMovement", "StockMovement.id", "StockMoveLine.stockMovementId")
+    .selectAll("StockMoveLine")
+    .select([
+      "StockMovement.movementType",
+      "StockMovement.executedAt",
+      "StockMovement.status",
+      "StockMovement.reasonCode",
+    ])
+    .where("StockMoveLine.lotId", "=", input.lotId)
+    .where("StockMovement.movementType", "=", "GOODS_ISSUE")
+    .orderBy("StockMoveLine.createdAt", "asc")
+    .execute();
+
+  return ok({ moveLines });
+}

package/src/modules/inventory/tailor.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig, definePlugins } from "@tailor-platform/sdk";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
+
+export default defineConfig({
+  name: "inventory",
+  db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
+});
+
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: `./generated/kysely-tailordb.ts` }),
+  enumConstantsPlugin({ distPath: "./generated/enums.ts" }),
+);

package/src/modules/inventory/tailor.d.ts

@@ -0,0 +1,13 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {}
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/src/modules/inventory/testing/commandTestUtils.ts

@@ -0,0 +1,29 @@
+import { expect } from "vitest";
+
+interface OkResult<T> {
+  ok: true;
+  value: T;
+}
+
+interface ErrResult {
+  ok: false;
+  error: unknown;
+}
+
+export function expectErr(
+  result: OkResult<unknown> | ErrResult,
+  errorClass: abstract new (...args: never[]) => Error,
+) {
+  expect(result.ok).toBe(false);
+  if (!result.ok) {
+    expect(result.error).toBeInstanceOf(errorClass);
+  }
+}
+
+export function expectOk<T>(result: OkResult<T> | ErrResult) {
+  expect(result.ok).toBe(true);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.value;
+}