@tailor-platform/erp-kit 0.4.1 → 0.5.0

package/src/modules/sales/query/getSalesOrder.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseSalesOrder, baseSalesOrderLine } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getSalesOrder";
+
+describe("getSalesOrder", () => {
+  it("returns sales order when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseSalesOrder);
+    spies.select.mockReturnValueOnce([baseSalesOrderLine]);
+
+    const result = await run(db, { id: baseSalesOrder.id });
+    const { salesOrder } = expectOk<{ salesOrder: unknown }>(result as never);
+
+    expect(salesOrder).not.toBeNull();
+    expect(salesOrder).toMatchObject({ id: baseSalesOrder.id });
+  });
+
+  it("returns line-level shipped and invoiced progress", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseSalesOrder);
+    spies.select.mockReturnValueOnce([baseSalesOrderLine]);
+
+    const result = await run(db, { id: baseSalesOrder.id });
+    const { salesOrder } = expectOk<{
+      salesOrder: {
+        fulfillmentTotals: {
+          totalOrdered: number;
+          totalShipped: number;
+          totalInvoiced: number;
+          openToShip: number;
+          openToInvoice: number;
+        };
+      };
+    }>(result as never);
+
+    expect(salesOrder.fulfillmentTotals).toEqual({
+      totalOrdered: 10,
+      totalShipped: 0,
+      totalInvoiced: 0,
+      openToShip: 10,
+      openToInvoice: 10,
+    });
+  });
+
+  it("returns null when sales order is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent-id" });
+    const { salesOrder } = expectOk<{ salesOrder: null }>(result as never);
+
+    expect(salesOrder).toBeNull();
+  });
+});

package/src/modules/sales/query/getSalesOrder.ts

@@ -0,0 +1,20 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { loadSalesOrderAggregate } from "../lib/repository";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetSalesOrderInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetSalesOrderInput) {
+  const aggregate = await loadSalesOrderAggregate(db, input.id);
+  return ok({
+    salesOrder: aggregate
+      ? {
+          ...aggregate.salesOrder,
+          lines: aggregate.lines,
+          fulfillmentTotals: aggregate.fulfillmentTotals,
+        }
+      : null,
+  });
+}

package/src/modules/sales/query/getSalesPaymentTerm.generated.ts

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

package/src/modules/sales/query/getSalesPaymentTerm.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePaymentTerm, inactivePaymentTerm } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getSalesPaymentTerm";
+
+describe("getSalesPaymentTerm", () => {
+  it("returns payment term when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+
+    const result = await run(db, { id: basePaymentTerm.id });
+    const { salesPaymentTerm } = expectOk<{ salesPaymentTerm: unknown }>(result as never);
+
+    expect(salesPaymentTerm).not.toBeNull();
+    expect(salesPaymentTerm).toMatchObject({
+      id: basePaymentTerm.id,
+      name: basePaymentTerm.name,
+    });
+  });
+
+  it("returns inactive payment term when requested directly", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(inactivePaymentTerm);
+
+    const result = await run(db, { id: inactivePaymentTerm.id });
+    const { salesPaymentTerm } = expectOk<{ salesPaymentTerm: { status: string } }>(
+      result as never,
+    );
+
+    expect(salesPaymentTerm.status).toBe("INACTIVE");
+  });
+
+  it("returns null when payment term is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { salesPaymentTerm } = expectOk<{ salesPaymentTerm: unknown }>(result as never);
+
+    expect(salesPaymentTerm).toBeNull();
+  });
+});

package/src/modules/sales/query/getSalesPaymentTerm.ts

@@ -0,0 +1,24 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson, type PaymentTermScheduleLineInput } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetSalesPaymentTermInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetSalesPaymentTermInput) {
+  const salesPaymentTerm = await db
+    .selectFrom("SalesPaymentTerm")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+  if (!salesPaymentTerm) {
+    return ok({ salesPaymentTerm: null });
+  }
+  return ok({
+    salesPaymentTerm: {
+      ...salesPaymentTerm,
+      scheduleLines: decodeJson<PaymentTermScheduleLineInput[]>(salesPaymentTerm.scheduleLines, []),
+    },
+  });
+}

package/src/modules/sales/query/getSalesPriceList.generated.ts

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

package/src/modules/sales/query/getSalesPriceList.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePriceList, draftPriceList } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getSalesPriceList";
+
+describe("getSalesPriceList", () => {
+  it("returns price list when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePriceList);
+
+    const result = await run(db, { id: basePriceList.id });
+    const { salesPriceList } = expectOk<{ salesPriceList: unknown }>(result as never);
+
+    expect(salesPriceList).not.toBeNull();
+    expect(salesPriceList).toMatchObject({ id: basePriceList.id });
+  });
+
+  it("returns inactive price list when requested by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(draftPriceList);
+
+    const result = await run(db, { id: draftPriceList.id });
+    const { salesPriceList } = expectOk<{ salesPriceList: { status: string } }>(result as never);
+
+    expect(salesPriceList.status).toBe("DRAFT");
+  });
+
+  it("returns null when price list is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { salesPriceList } = expectOk<{ salesPriceList: unknown }>(result as never);
+
+    expect(salesPriceList).toBeNull();
+  });
+});

package/src/modules/sales/query/getSalesPriceList.ts

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

package/src/modules/sales/query/getShipment.generated.ts

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

package/src/modules/sales/query/getShipment.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseShipment, postedShipment, baseShipmentLine } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getShipment";
+
+describe("getShipment", () => {
+  it("returns shipment when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseShipment);
+    spies.select.mockReturnValueOnce([baseShipmentLine]);
+
+    const result = await run(db, { id: baseShipment.id });
+    const { shipment } = expectOk<{ shipment: unknown }>(result as never);
+
+    expect(shipment).not.toBeNull();
+    expect(shipment).toMatchObject({ id: baseShipment.id });
+  });
+
+  it("returns posted shipment with lines", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(postedShipment);
+    spies.select.mockReturnValueOnce([baseShipmentLine]);
+
+    const result = await run(db, { id: postedShipment.id });
+    const { shipment } = expectOk<{
+      shipment: { status: string; lines: unknown[] };
+    }>(result as never);
+
+    expect(shipment.status).toBe("POSTED");
+    expect(shipment.lines).toHaveLength(1);
+  });
+
+  it("returns null when shipment is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "non-existent-id" });
+    const { shipment } = expectOk<{ shipment: null }>(result as never);
+
+    expect(shipment).toBeNull();
+  });
+});

package/src/modules/sales/query/getShipment.ts

@@ -0,0 +1,12 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { loadShipmentAggregate } from "../lib/repository";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetShipmentInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetShipmentInput) {
+  const aggregate = await loadShipmentAggregate(db, input.id);
+  return ok({ shipment: aggregate ? { ...aggregate.shipment, lines: aggregate.lines } : null });
+}

package/src/modules/sales/query/getSyncJob.generated.ts

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

package/src/modules/sales/query/getSyncJob.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseSyncJob, failedSyncJob } from "../testing/fixtures";
+import { expectOk } from "../testing/commandTestUtils";
+import { run } from "./getSyncJob";
+
+describe("getSyncJob", () => {
+  it("returns sync job when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseSyncJob);
+
+    const result = await run(db, { id: baseSyncJob.id });
+    const { syncJob } = expectOk<{ syncJob: unknown }>(result as never);
+
+    expect(syncJob).not.toBeNull();
+    expect(syncJob).toMatchObject({ id: baseSyncJob.id });
+  });
+
+  it("returns failed sync job with counts and error summary", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(failedSyncJob);
+
+    const result = await run(db, { id: failedSyncJob.id });
+    const { syncJob } = expectOk<{
+      syncJob: { status: string; errorCount: number; errorSummary: string };
+    }>(result as never);
+
+    expect(syncJob.status).toBe("FAILED");
+    expect(syncJob.errorCount).toBe(1);
+    expect(syncJob.errorSummary).toBe("Timeout");
+  });
+
+  it("returns null when sync job is not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent-id" });
+    const { syncJob } = expectOk<{ syncJob: unknown }>(result as never);
+
+    expect(syncJob).toBeNull();
+  });
+});

package/src/modules/sales/query/getSyncJob.ts

@@ -0,0 +1,24 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { decodeJson } from "../lib/domain";
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface GetSyncJobInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetSyncJobInput) {
+  const syncJob = await db
+    .selectFrom("SyncJob")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+  if (!syncJob) {
+    return ok({ syncJob: null });
+  }
+  return ok({
+    syncJob: {
+      ...syncJob,
+      context: decodeJson<Record<string, unknown> | null>(syncJob.context, null),
+    },
+  });
+}

package/src/modules/sales/query/listChannelOrdersByStatus.generated.ts

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

package/src/modules/sales/query/listChannelOrdersByStatus.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 { StatusFilterRequiredError } from "../lib/errors.generated";
+import { baseChannelOrder, baseCompany, baseChannel } from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./listChannelOrdersByStatus";
+
+describe("listChannelOrdersByStatus", () => {
+  it("lists pending conversion channel orders", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseChannelOrder]);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      statuses: ["PENDING_CONVERSION"],
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+    expect((items[0] as { rawPayload: unknown }).rawPayload).toEqual({ orderId: "EXT-001" });
+  });
+
+  it("lists exceptional channel orders for replay", async () => {
+    const exceptionOrder = { ...baseChannelOrder, id: "channel-order-2", status: "EXCEPTION" };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([exceptionOrder]);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      statuses: ["EXCEPTION"],
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("filters results by channel when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseChannelOrder]);
+
+    const result = await run(db, {
+      companyId: baseCompany.id,
+      statuses: ["PENDING_CONVERSION"],
+      channelId: baseChannel.id,
+    });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("throws when no status filter is provided", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: baseCompany.id, statuses: [] });
+    expectErr(result as never, StatusFilterRequiredError);
+  });
+});

package/src/modules/sales/query/listChannelOrdersByStatus.ts

@@ -0,0 +1,53 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { StatusFilterRequiredError } from "../lib/errors.generated";
+import { decodeJson } from "../lib/domain";
+import {
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+  err,
+  ok,
+  type PaginationInput,
+  type ReadonlyDB,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "createdAt" | "orderDate" | "status";
+
+export interface ListChannelOrdersByStatusInput extends PaginationInput<OrderByField> {
+  companyId: string;
+  statuses: string[];
+  channelId?: string;
+  dateFrom?: Date;
+  dateTo?: Date;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListChannelOrdersByStatusInput) {
+  if (!input.statuses?.length) {
+    return err(new StatusFilterRequiredError(input.companyId));
+  }
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "createdAt";
+  const orderDirection = input.orderDirection ?? "desc";
+
+  const rows = await db
+    .selectFrom("ChannelOrder")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  const filtered = rows
+    .filter((row) => input.statuses.includes(row.status))
+    .filter((row) => !input.channelId || row.channelId === input.channelId)
+    .filter((row) => !input.dateFrom || !row.orderDate || row.orderDate >= input.dateFrom)
+    .filter((row) => !input.dateTo || !row.orderDate || row.orderDate <= input.dateTo)
+    .map((row) => ({
+      ...row,
+      rawPayload: decodeJson<Record<string, unknown> | null>(row.rawPayload, null),
+      normalizedPayload: decodeJson<Record<string, unknown> | null>(row.normalizedPayload, null),
+    }));
+
+  return ok(buildPaginatedResult(filtered, limit));
+}

package/src/modules/sales/query/listChannels.generated.ts

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

package/src/modules/sales/query/listChannels.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError } from "../lib/errors.generated";
+import { baseChannel, baseCompany, draftChannel } from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./listChannels";
+
+describe("listChannels", () => {
+  it("lists channels by company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseChannel, draftChannel]);
+
+    const result = await run(db, { companyId: baseCompany.id });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters channels by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseChannel]);
+
+    const result = await run(db, { companyId: baseCompany.id, status: "ACTIVE" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("throws when company scope is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { companyId: "" });
+    expectErr(result as never, CompanyScopeRequiredError);
+  });
+});

package/src/modules/sales/query/listChannels.ts

@@ -0,0 +1,39 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { CompanyScopeRequiredError } from "../lib/errors.generated";
+import {
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+  err,
+  ok,
+  type PaginationInput,
+  type ReadonlyDB,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "name" | "status" | "createdAt";
+
+export interface ListChannelsInput extends PaginationInput<OrderByField> {
+  companyId: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListChannelsInput) {
+  if (!input.companyId) {
+    return err(new CompanyScopeRequiredError("channels"));
+  }
+  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("Channel").selectAll().where("companyId", "=", input.companyId);
+  if (input.status) {
+    query = query.where("status", "=", input.status as never);
+  }
+
+  const channels = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+  return ok(buildPaginatedResult(channels, limit));
+}

package/src/modules/sales/query/listListingsByChannel.generated.ts

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

package/src/modules/sales/query/listListingsByChannel.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { ChannelIdRequiredError } from "../lib/errors.generated";
+import { baseChannel, baseListing, draftListing } from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./listListingsByChannel";
+
+describe("listListingsByChannel", () => {
+  it("lists listings under a channel", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseListing, draftListing]);
+
+    const result = await run(db, { channelId: baseChannel.id });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(2);
+  });
+
+  it("filters listings by status when provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseListing]);
+
+    const result = await run(db, { channelId: baseChannel.id, status: "ACTIVE" });
+    const { items } = expectOk<{ items: unknown[]; hasNextPage: boolean }>(result as never);
+
+    expect(items).toHaveLength(1);
+  });
+
+  it("throws when channel id is missing", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { channelId: "" });
+    expectErr(result as never, ChannelIdRequiredError);
+  });
+});

package/src/modules/sales/query/listListingsByChannel.ts

@@ -0,0 +1,39 @@
+import type { DB } from "../generated/kysely-tailordb";
+import { ChannelIdRequiredError } from "../lib/errors.generated";
+import {
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+  err,
+  ok,
+  type PaginationInput,
+  type ReadonlyDB,
+} from "@tailor-platform/erp-kit/module";
+
+type OrderByField = "createdAt" | "status" | "externalIdentifier";
+
+export interface ListListingsByChannelInput extends PaginationInput<OrderByField> {
+  channelId: string;
+  status?: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ListListingsByChannelInput) {
+  if (!input.channelId) {
+    return err(new ChannelIdRequiredError("listing"));
+  }
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "createdAt";
+  const orderDirection = input.orderDirection ?? "desc";
+
+  let query = db.selectFrom("Listing").selectAll().where("channelId", "=", input.channelId);
+  if (input.status) {
+    query = query.where("status", "=", input.status as never);
+  }
+
+  const listings = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+  return ok(buildPaginatedResult(listings, limit));
+}

package/src/modules/sales/query/listSalesCreditNotesByInvoice.generated.ts

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