@tailor-platform/erp-kit 0.6.0 → 0.7.0

package/src/modules/finance-ledger/query/getPeriodClose.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { basePeriodClose } from "../testing/fixtures";
+import { run } from "./getPeriodClose";
+
+describe("getPeriodClose", () => {
+  it("returns period close when found by accounting period id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(basePeriodClose);
+
+    const result = await run(db, { accountingPeriodId: basePeriodClose.accountingPeriodId });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.periodClose).toEqual(basePeriodClose);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { accountingPeriodId: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.periodClose).toBeNull();
+    }
+  });
+});

package/src/modules/finance-ledger/query/getPeriodClose.ts

@@ -0,0 +1,21 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetPeriodCloseInput {
+  accountingPeriodId: string;
+}
+
+/**
+ * Function: getPeriodClose
+ *
+ * Retrieves a single period close by accounting period id.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetPeriodCloseInput) {
+  const result = await db
+    .selectFrom("PeriodClose")
+    .selectAll()
+    .where("accountingPeriodId", "=", input.accountingPeriodId)
+    .executeTakeFirst();
+
+  return ok({ periodClose: result ?? null });
+}

package/src/modules/finance-ledger/query/getSubledgerTransferStatus.generated.ts

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

package/src/modules/finance-ledger/query/getSubledgerTransferStatus.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { AccountingPeriodNotFoundError } from "../lib/errors.generated";
+import { baseAccountingPeriod, baseJournalEntry, postedJournalEntry } from "../testing/fixtures";
+import { run } from "./getSubledgerTransferStatus";
+
+describe("getSubledgerTransferStatus", () => {
+  it("returns error when accounting period does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined); // AccountingPeriod lookup
+
+    const result = await run(db, { accountingPeriodId: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AccountingPeriodNotFoundError);
+    }
+  });
+
+  it("returns status for all 4 modules", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseAccountingPeriod); // AccountingPeriod lookup
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { accountingPeriodId: "period-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.statuses).toHaveLength(4);
+      const modules = result.value.statuses.map((s) => s.module);
+      expect(modules).toEqual(["purchase", "sales", "inventory", "manufacturing"]);
+    }
+  });
+
+  it("returns zero counts when no entries exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseAccountingPeriod); // AccountingPeriod lookup
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { accountingPeriodId: "period-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      for (const status of result.value.statuses) {
+        expect(status.totalExpected).toBe(0);
+        expect(status.acknowledged).toBe(0);
+        expect(status.outstanding).toBe(0);
+      }
+    }
+  });
+
+  it("correctly counts posted vs draft entries", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseAccountingPeriod); // AccountingPeriod lookup
+    // First module (purchase) has 2 entries: 1 draft + 1 posted
+    spies.select
+      .mockReturnValueOnce([baseJournalEntry, postedJournalEntry])
+      // Remaining modules have no entries
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { accountingPeriodId: "period-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      const purchaseStatus = result.value.statuses[0];
+      expect(purchaseStatus.totalExpected).toBe(2);
+      expect(purchaseStatus.acknowledged).toBe(1);
+      expect(purchaseStatus.outstanding).toBe(1);
+    }
+  });
+
+  it("returns correct outstanding counts", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseAccountingPeriod); // AccountingPeriod lookup
+    // All entries posted for purchase module
+    spies.select
+      .mockReturnValueOnce([postedJournalEntry])
+      // Sales has one draft
+      .mockReturnValueOnce([baseJournalEntry])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { accountingPeriodId: "period-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      const purchaseStatus = result.value.statuses[0];
+      expect(purchaseStatus.totalExpected).toBe(1);
+      expect(purchaseStatus.acknowledged).toBe(1);
+      expect(purchaseStatus.outstanding).toBe(0);
+
+      const salesStatus = result.value.statuses[1];
+      expect(salesStatus.totalExpected).toBe(1);
+      expect(salesStatus.acknowledged).toBe(0);
+      expect(salesStatus.outstanding).toBe(1);
+    }
+  });
+});

package/src/modules/finance-ledger/query/getSubledgerTransferStatus.ts

@@ -0,0 +1,68 @@
+import { ok, err, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+import { AccountingPeriodNotFoundError } from "../lib/errors.generated";
+
+export interface GetSubledgerTransferStatusInput {
+  accountingPeriodId: string;
+}
+
+interface ModuleStatus {
+  module: string;
+  journalType: string;
+  totalExpected: number;
+  acknowledged: number;
+  outstanding: number;
+}
+
+const SUBLEDGER_MODULES = [
+  { module: "purchase", journalType: "PURCHASE" as const },
+  { module: "sales", journalType: "SALES" as const },
+  { module: "inventory", journalType: "INVENTORY" as const },
+  { module: "manufacturing", journalType: "MANUFACTURING" as const },
+];
+
+/**
+ * Function: getSubledgerTransferStatus
+ *
+ * Returns transfer completeness status for all subledger modules for a given
+ * accounting period. Per-module status includes: totalExpected, acknowledged,
+ * outstanding. Registered modules: purchase, sales, inventory, manufacturing.
+ * Returns status for all modules even if zero expected events.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetSubledgerTransferStatusInput) {
+  // Validate that the accounting period exists
+  const period = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("id", "=", input.accountingPeriodId)
+    .executeTakeFirst();
+
+  if (!period) {
+    return err(new AccountingPeriodNotFoundError(input.accountingPeriodId));
+  }
+
+  const statuses: ModuleStatus[] = [];
+
+  for (const subledger of SUBLEDGER_MODULES) {
+    // Count all entries of this type for the period
+    const allEntries = await db
+      .selectFrom("JournalEntry")
+      .selectAll()
+      .where("accountingPeriodId", "=", input.accountingPeriodId)
+      .where("journalType", "=", subledger.journalType)
+      .execute();
+
+    const totalExpected = allEntries.length;
+    const acknowledged = allEntries.filter((e) => e.status === "POSTED").length;
+
+    statuses.push({
+      module: subledger.module,
+      journalType: subledger.journalType,
+      totalExpected,
+      acknowledged,
+      outstanding: totalExpected - acknowledged,
+    });
+  }
+
+  return ok({ statuses });
+}

package/src/modules/finance-ledger/query/getTrialBalance.generated.ts

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

package/src/modules/finance-ledger/query/getTrialBalance.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseTrialBalance, baseTrialBalanceLine } from "../testing/fixtures";
+import { run } from "./getTrialBalance";
+
+describe("getTrialBalance", () => {
+  it("returns trial balance with lines when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseTrialBalance).mockReturnValueOnce([baseTrialBalanceLine]);
+
+    const result = await run(db, { id: baseTrialBalance.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.trialBalance).toEqual(baseTrialBalance);
+      expect(result.value.lines).toEqual([baseTrialBalanceLine]);
+    }
+  });
+
+  it("returns null with empty lines when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.trialBalance).toBeNull();
+      expect(result.value.lines).toEqual([]);
+    }
+  });
+});

package/src/modules/finance-ledger/query/getTrialBalance.ts

@@ -0,0 +1,30 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetTrialBalanceInput {
+  id: string;
+}
+
+/**
+ * Function: getTrialBalance
+ *
+ * Retrieves a single trial balance by id, along with its associated trial balance lines.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetTrialBalanceInput) {
+  const result = await db
+    .selectFrom("TrialBalance")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  const lines = result
+    ? await db
+        .selectFrom("TrialBalanceLine")
+        .selectAll()
+        .where("trialBalanceId", "=", input.id)
+        .orderBy("accountCode", "asc")
+        .execute()
+    : [];
+
+  return ok({ trialBalance: result ?? null, lines });
+}

package/src/modules/finance-ledger/query/listAccountingPeriods.generated.ts

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

package/src/modules/finance-ledger/query/listAccountingPeriods.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { EmptyResultError } from "../lib/errors.generated";
+import { baseAccountingPeriod, closedPeriod } from "../testing/fixtures";
+import { run } from "./listAccountingPeriods";
+
+describe("listAccountingPeriods", () => {
+  it("returns error when neither companyId nor fiscalYearId is provided", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, {});
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(EmptyResultError);
+    }
+  });
+
+  it("returns all accounting periods for a company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAccountingPeriod, closedPeriod]);
+
+    const result = await run(db, { companyId: "company-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseAccountingPeriod, closedPeriod]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns accounting periods filtered by fiscal year", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAccountingPeriod]);
+
+    const result = await run(db, { fiscalYearId: "fiscal-year-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseAccountingPeriod]);
+    }
+  });
+
+  it("returns accounting periods filtered by status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([closedPeriod]);
+
+    const result = await run(db, { companyId: "company-1", status: "CLOSED" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([closedPeriod]);
+    }
+  });
+
+  it("returns accounting periods filtered by period type", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAccountingPeriod]);
+
+    const result = await run(db, { companyId: "company-1", periodType: "OPERATING" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseAccountingPeriod]);
+    }
+  });
+
+  it("returns empty list when no accounting periods match", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { companyId: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+});

package/src/modules/finance-ledger/query/listAccountingPeriods.ts

@@ -0,0 +1,61 @@
+import {
+  ok,
+  err,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+import type { AccountingPeriodPeriodType, AccountingPeriodStatus } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+import { EmptyResultError } from "../lib/errors.generated";
+
+type AccountingPeriodOrderByField = "startDate" | "endDate" | "name" | "status" | "createdAt";
+
+export interface ListAccountingPeriodsInput extends PaginationInput<AccountingPeriodOrderByField> {
+  companyId?: string;
+  fiscalYearId?: string;
+  status?: string;
+  periodType?: string;
+}
+
+/**
+ * Function: listAccountingPeriods
+ *
+ * Lists accounting periods with optional filters for company, fiscal year,
+ * status, and period type. At least one scoping parameter (companyId or
+ * fiscalYearId) is required. All filters use AND logic.
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListAccountingPeriodsInput) {
+  if (!input.companyId && !input.fiscalYearId) {
+    return err(new EmptyResultError("companyId or fiscalYearId is required"));
+  }
+
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "startDate";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  let query = db.selectFrom("AccountingPeriod").selectAll();
+
+  if (input.companyId) {
+    query = query.where("companyId", "=", input.companyId);
+  }
+  if (input.fiscalYearId) {
+    query = query.where("fiscalYearId", "=", input.fiscalYearId);
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as AccountingPeriodStatus);
+  }
+  if (input.periodType) {
+    query = query.where("periodType", "=", input.periodType as AccountingPeriodPeriodType);
+  }
+
+  const results = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(results, limit));
+}

package/src/modules/finance-ledger/query/listFinancialStatements.generated.ts

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

package/src/modules/finance-ledger/query/listFinancialStatements.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseFinancialStatement, finalizedFinancialStatement } from "../testing/fixtures";
+import { run } from "./listFinancialStatements";
+
+describe("listFinancialStatements", () => {
+  it("returns all financial statements for a company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFinancialStatement, finalizedFinancialStatement]);
+
+    const result = await run(db, { companyId: "company-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFinancialStatement, finalizedFinancialStatement]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns financial statements filtered by statement type", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFinancialStatement]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      statementType: "BALANCE_SHEET",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFinancialStatement]);
+    }
+  });
+
+  it("returns financial statements filtered by status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([finalizedFinancialStatement]);
+
+    const result = await run(db, { companyId: "company-1", status: "FINALIZED" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([finalizedFinancialStatement]);
+    }
+  });
+
+  it("returns financial statements filtered by dateRange", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFinancialStatement]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      startDate: new Date("2024-01-01"),
+      endDate: new Date("2024-01-31"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFinancialStatement]);
+    }
+  });
+
+  it("returns empty list when no financial statements match", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { companyId: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+});

package/src/modules/finance-ledger/query/listFinancialStatements.ts

@@ -0,0 +1,62 @@
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "@tailor-platform/erp-kit/module";
+import type { FinancialStatementStatementType, FinancialStatementStatus } from "../generated/enums";
+import type { DB } from "../generated/kysely-tailordb";
+
+type FinancialStatementOrderByField = "createdAt" | "statementType" | "status" | "generatedAt";
+
+export interface ListFinancialStatementsInput extends PaginationInput<FinancialStatementOrderByField> {
+  companyId: string;
+  statementType?: string;
+  status?: string;
+  startDate?: Date;
+  endDate?: Date;
+}
+
+/**
+ * Function: listFinancialStatements
+ *
+ * Lists financial statement headers for a company with optional filters
+ * for statement type, status, and date range (by reportingDate).
+ */
+export async function run(db: ReadonlyDB<DB>, input: ListFinancialStatementsInput) {
+  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("FinancialStatement")
+    .selectAll()
+    .where("companyId", "=", input.companyId);
+
+  if (input.statementType) {
+    query = query.where(
+      "statementType",
+      "=",
+      input.statementType as FinancialStatementStatementType,
+    );
+  }
+  if (input.status) {
+    query = query.where("status", "=", input.status as FinancialStatementStatus);
+  }
+  if (input.startDate) {
+    query = query.where("reportingDate", ">=", input.startDate);
+  }
+  if (input.endDate) {
+    query = query.where("reportingDate", "<=", input.endDate);
+  }
+
+  const results = await query
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+
+  return ok(buildPaginatedResult(results, limit));
+}

package/src/modules/finance-ledger/query/listFiscalYears.generated.ts

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

package/src/modules/finance-ledger/query/listFiscalYears.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 { baseFiscalYear, baseFiscalYear2 } from "../testing/fixtures";
+import { run } from "./listFiscalYears";
+
+describe("listFiscalYears", () => {
+  it("returns all fiscal years for a company", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFiscalYear, baseFiscalYear2]);
+
+    const result = await run(db, { companyId: "company-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFiscalYear, baseFiscalYear2]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+
+  it("returns fiscal years filtered by startDate", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFiscalYear2]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      startDate: new Date("2025-01-01"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFiscalYear2]);
+    }
+  });
+
+  it("returns fiscal years filtered by endDate", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseFiscalYear]);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      endDate: new Date("2024-12-31"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([baseFiscalYear]);
+    }
+  });
+
+  it("returns empty list when no fiscal years match", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { companyId: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.items).toEqual([]);
+      expect(result.value.hasNextPage).toBe(false);
+    }
+  });
+});