@flowdular/sdk 0.3.1 → 0.3.2

package/.ai/references/catalog/tests/endpoints.test.ts

@@ -317,4 +317,273 @@ describe('catalog lifecycle and history endpoints', () => {
 			(await (await runtime.service()).get('tenant-a', item.id))?.status,
 		).toBe('active');
 	});
+
+	it('rejects a bulk lifecycle mutation without a valid CSRF token', async () => {
+		const actor = principal([CATALOG_PERMISSIONS.manage]);
+		const runtime = catalogRuntime(await catalogTestProvider());
+		const item = await (
+			await runtime.service()
+		).create('tenant-a', seedInput('A-1'), OWNER);
+		const response = await route(
+			createCatalogRoutes(authRuntime(actor), runtime),
+			'/api/catalog/items/archive-many',
+			'POST',
+		).handler(
+			context(
+				mutation('/api/catalog/items/archive-many', { ids: [item.id] }, 'bad'),
+				actor,
+			),
+		);
+		expect(response.status).toBe(403);
+		expect(
+			(await (await runtime.service()).get('tenant-a', item.id))?.status,
+		).toBe('active');
+	});
+
+	it('bounds the ids of a bulk lifecycle mutation', async () => {
+		const actor = principal([CATALOG_PERMISSIONS.manage]);
+		const routes = createCatalogRoutes(
+			authRuntime(actor),
+			catalogRuntime(await catalogTestProvider()),
+		);
+		for (const body of [
+			{},
+			{ ids: [] },
+			{ ids: Array.from({ length: 101 }, (_, index) => `id-${index}`) },
+			{ ids: ['same', 'same'] },
+			{ ids: [''] },
+			{ ids: ['x'.repeat(129)] },
+		]) {
+			for (const path of [
+				'/api/catalog/items/archive-many',
+				'/api/catalog/items/restore-many',
+			]) {
+				const response = await route(routes, path, 'POST').handler(
+					context(mutation(path, body), actor),
+				);
+				expect(response.status, `${path} ${JSON.stringify(body)}`).toBe(400);
+				expect(await response.json()).toMatchObject({
+					error: { code: 'INVALID_INPUT' },
+				});
+			}
+		}
+	});
+
+	it('answers one outcome per id and one history row per accepted transition', async () => {
+		const actor = principal([
+			CATALOG_PERMISSIONS.read,
+			CATALOG_PERMISSIONS.manage,
+		]);
+		const runtime = catalogRuntime(await catalogTestProvider());
+		const service = await runtime.service();
+		const first = await service.create('tenant-a', seedInput('A-1'), OWNER);
+		const second = await service.create('tenant-a', seedInput('A-2'), OWNER);
+		const foreign = await service.create('tenant-b', seedInput('B-1'), OWNER);
+		const routes = createCatalogRoutes(authRuntime(actor), runtime);
+
+		const archived = await route(
+			routes,
+			'/api/catalog/items/archive-many',
+			'POST',
+		).handler(
+			context(
+				mutation('/api/catalog/items/archive-many', {
+					ids: [first.id, 'missing', foreign.id, second.id],
+				}),
+				actor,
+			),
+		);
+		expect(archived.status).toBe(200);
+		expect(await archived.json()).toEqual({
+			outcomes: [
+				{ id: first.id, outcome: 'updated' },
+				{ id: 'missing', outcome: 'not-found' },
+				{ id: foreign.id, outcome: 'not-found' },
+				{ id: second.id, outcome: 'updated' },
+			],
+		});
+		expect((await service.get('tenant-b', foreign.id))?.status).toBe('active');
+
+		const restored = await route(
+			routes,
+			'/api/catalog/items/restore-many',
+			'POST',
+		).handler(
+			context(
+				mutation('/api/catalog/items/restore-many', { ids: [first.id] }),
+				actor,
+			),
+		);
+		expect(await restored.json()).toEqual({
+			outcomes: [{ id: first.id, outcome: 'updated' }],
+		});
+
+		for (const [id, actions] of [
+			[first.id, ['restored', 'archived', 'created']],
+			[second.id, ['archived', 'created']],
+		] as const) {
+			const history = await service.history('tenant-a', {
+				recordId: id,
+				limit: 10,
+				cursor: null,
+			});
+			expect(history.entries.map((entry) => entry.action)).toEqual(actions);
+			expect(history.entries[0]?.actor).toEqual({
+				kind: 'user',
+				id: 'account-a',
+				label: 'Owner',
+			});
+		}
+	});
+});
+
+function seedInput(sku: string) {
+	return {
+		sku,
+		name: 'Item ' + sku,
+		kind: 'product' as const,
+		unit: 'each',
+		basePriceMinor: 100,
+		currency: 'EUR',
+	};
+}
+
+const OWNER = { kind: 'user', id: 'account-a', label: 'Owner' } as const;
+
+function listRequest(query: Record<string, string>): Request {
+	return new Request(
+		'https://erp.example/api/catalog/items?' +
+			new URLSearchParams(query).toString(),
+	);
+}
+
+/* Flips the first character of one dot-separated segment of a signed cursor. */
+function tamper(cursor: string, segment: number): string {
+	const parts = cursor.split('.');
+	const target = parts[segment]!;
+	const first = target[0] === 'A' ? 'B' : 'A';
+	parts[segment] = first + target.slice(1);
+	return parts.join('.');
+}
+
+interface ListBody {
+	readonly items: readonly { readonly id: string; readonly sku: string }[];
+	readonly page: { readonly nextCursor: string | null; readonly limit: number };
+}
+
+describe('catalog items list endpoint', () => {
+	async function listing(count: number) {
+		const actor = principal([CATALOG_PERMISSIONS.read]);
+		const runtime = catalogRuntime(await catalogTestProvider());
+		const service = await runtime.service();
+		for (let index = 0; index < count; index += 1) {
+			await service.create(
+				'tenant-a',
+				seedInput(`SKU-${String(index).padStart(3, '0')}`),
+				OWNER,
+			);
+		}
+		await service.create('tenant-b', seedInput('OTHER-1'), OWNER);
+		const list = route(
+			createCatalogRoutes(authRuntime(actor), runtime),
+			'/api/catalog/items',
+			'GET',
+		);
+		const read = async (
+			query: Record<string, string>,
+			as = actor,
+		): Promise<{ status: number; body: ListBody }> => {
+			const response = await list.handler(context(listRequest(query), as));
+			return {
+				status: response.status,
+				body: (await response.json()) as ListBody,
+			};
+		};
+		return { read, runtime };
+	}
+
+	it('answers consecutive pages without overlap or gap, a cursor only on a full page', async () => {
+		const { read } = await listing(5);
+		const first = await read({ limit: '2', sort: 'sku' });
+		expect(first.status).toBe(200);
+		expect(first.body.items.map((item) => item.sku)).toEqual([
+			'SKU-000',
+			'SKU-001',
+		]);
+		expect(first.body.page).toEqual({
+			nextCursor: expect.any(String),
+			limit: 2,
+		});
+		const second = await read({
+			limit: '2',
+			sort: 'sku',
+			cursor: first.body.page.nextCursor!,
+		});
+		expect(second.body.items.map((item) => item.sku)).toEqual([
+			'SKU-002',
+			'SKU-003',
+		]);
+		const third = await read({
+			limit: '2',
+			sort: 'sku',
+			cursor: second.body.page.nextCursor!,
+		});
+		expect(third.body.items.map((item) => item.sku)).toEqual(['SKU-004']);
+		expect(third.body.page.nextCursor).toBeNull();
+
+		const whole = await read({});
+		expect(whole.body.items).toHaveLength(5);
+		expect(whole.body.page).toEqual({ nextCursor: null, limit: 50 });
+	});
+
+	it('refuses a tampered, foreign, refiltered or re-sorted cursor and an unknown sort', async () => {
+		const { read } = await listing(3);
+		const query = { limit: '2', sort: 'name', direction: 'asc', q: 'sku' };
+		const cursor = (await read(query)).body.page.nextCursor!;
+		expect((await read({ ...query, cursor })).status).toBe(200);
+
+		const refused = async (
+			changes: Record<string, string>,
+			as?: AuthPrincipal,
+		) => {
+			const result = await read({ ...query, ...changes }, as);
+			expect(result.status, JSON.stringify(changes)).toBe(400);
+			return (result.body as unknown as { error: { code: string } }).error.code;
+		};
+		for (const segment of [0, 1, 2]) {
+			expect(await refused({ cursor: tamper(cursor, segment) })).toBe(
+				'CURSOR_INVALID',
+			);
+		}
+		expect(
+			await refused(
+				{ cursor },
+				principal([CATALOG_PERMISSIONS.read], 'tenant-b'),
+			),
+		).toBe('CURSOR_INVALID');
+		expect(await refused({ cursor, q: 'other' })).toBe('CURSOR_INVALID');
+		expect(await refused({ cursor, kind: 'product' })).toBe('CURSOR_INVALID');
+		expect(await refused({ cursor, sort: 'sku' })).toBe('CURSOR_INVALID');
+		expect(await refused({ cursor, direction: 'desc' })).toBe('CURSOR_INVALID');
+		expect(await refused({ cursor: 'not-a-cursor' })).toBe('CURSOR_INVALID');
+		expect(await refused({ sort: 'price' })).toBe('INVALID_INPUT');
+		expect(await refused({ direction: 'up' })).toBe('INVALID_INPUT');
+		expect(await refused({ status: 'gone' })).toBe('INVALID_INPUT');
+		expect(await refused({ limit: '201' })).toBe('INVALID_INPUT');
+	});
+
+	it('pushes the filters into the read and never crosses the tenant', async () => {
+		const { read, runtime } = await listing(2);
+		const service = await runtime.service();
+		const [archived] = (await read({ sort: 'sku' })).body.items;
+		await service.archive('tenant-a', archived!.id, OWNER);
+		expect(
+			(await read({ status: 'archived' })).body.items.map((item) => item.sku),
+		).toEqual(['SKU-000']);
+		expect(
+			(await read({ status: 'active' })).body.items.map((item) => item.sku),
+		).toEqual(['SKU-001']);
+		expect((await read({ kind: 'service' })).body.items).toEqual([]);
+		expect((await read({ q: 'other' })).body.items).toEqual([]);
+	});
 });

package/.ai/references/catalog/tests/export.test.ts

@@ -0,0 +1,134 @@
+import type { DefinedListExport } from '@flowdular/sdk/server';
+import { EXPORT_LISTS_CAPABILITY } from '@flowdular/sdk/modules/exports';
+import type { PlatformServerContext } from '@flowdular/sdk/modules/auth/server';
+import { afterAll, afterEach, describe, expect, it } from 'vitest';
+import { CATALOG_ITEMS_EXPORT_LIST_ID } from '../src/domain/lists.ts';
+import { createServerComposition } from '../src/platform.ts';
+import {
+	createCatalogRuntime,
+	type CatalogRuntime,
+} from '../src/server/runtime.ts';
+import {
+	catalogTestProvider,
+	closeCatalogTestDatabases,
+} from './support/database.ts';
+
+const ACTOR = { kind: 'user', id: 'account-a', label: 'Owner' } as const;
+
+const disposals = new Set<() => Promise<void>>();
+
+afterEach(async () => {
+	await Promise.all([...disposals].map((dispose) => dispose()));
+	disposals.clear();
+});
+
+afterAll(closeCatalogTestDatabases);
+
+/* The composition context a test needs: leased databases, a capability map
+   and inert registries for what this test does not observe. */
+async function compose(registered: Map<string, readonly DefinedListExport[]>) {
+	const capabilities = new Map<string, unknown>();
+	capabilities.set(EXPORT_LISTS_CAPABILITY, {
+		register: (moduleId: string, lists: readonly DefinedListExport[]) =>
+			registered.set(moduleId, lists),
+	});
+	const context = {
+		environment: { NODE_ENV: 'test' },
+		databases: await catalogTestProvider(),
+		auth: {},
+		agentTools: { register: () => undefined },
+		dataClasses: { declare: () => undefined },
+		capabilities: {
+			register: (id: string, value: unknown) => capabilities.set(id, value),
+			get: (id: string) => capabilities.get(id) ?? null,
+			has: (id: string) => capabilities.has(id),
+		},
+	} as unknown as PlatformServerContext;
+	const composition = createServerComposition(context);
+	disposals.add(() => composition.dispose?.() ?? Promise.resolve());
+	return composition;
+}
+
+async function seed(runtime: CatalogRuntime, tenantId: string, skus: string[]) {
+	const service = await runtime.service();
+	for (const sku of skus) {
+		await service.create(
+			tenantId,
+			{
+				sku,
+				name: 'Item ' + sku,
+				kind: 'product',
+				unit: 'pcs',
+				basePriceMinor: 1_000,
+				currency: 'PLN',
+			},
+			ACTOR,
+		);
+	}
+}
+
+describe('catalog items list export', () => {
+	it('registers catalog.core.items with its columns while composing', async () => {
+		const registered = new Map<string, readonly DefinedListExport[]>();
+		const composition = await compose(registered);
+		composition.start?.();
+		const lists = registered.get('catalog.core');
+		expect(lists?.map((list) => list.id)).toEqual([
+			CATALOG_ITEMS_EXPORT_LIST_ID,
+		]);
+		expect(lists?.[0]).toMatchObject({
+			permission: 'catalog.items.read',
+			columns: [
+				{ key: 'sku' },
+				{ key: 'name' },
+				{ key: 'kind' },
+				{ key: 'unit' },
+				{ key: 'basePriceMinor' },
+				{ key: 'currency' },
+				{ key: 'status' },
+			],
+		});
+		expect(lists?.[0]?.header.trim()).toBe(
+			'SKU,Name,Kind,Unit,Base price (minor units),Currency,Status',
+		);
+	});
+
+	it('streams one workspace in SKU order, page by page, and none of another', async () => {
+		const registered = new Map<string, readonly DefinedListExport[]>();
+		const composition = await compose(registered);
+		const list = registered.get('catalog.core')![0]!;
+		/* The composition owns its runtime; the rows are seeded through a second
+		   one over the same cluster. */
+		const runtime = createCatalogRuntime({
+			databases: await catalogTestProvider(),
+			purpose: 'test',
+		});
+		disposals.add(() => runtime.dispose());
+		await seed(runtime, 'tenant-a', ['C-3', 'A-1', 'B-2', 'D-4', 'E-5']);
+		await seed(runtime, 'tenant-b', ['Z-9']);
+		const principal = {
+			accountId: 'account-a',
+			tenantId: 'tenant-a',
+			scopes: ['catalog.items.read'],
+		};
+
+		const first = await list.page(principal, null, 2);
+		expect(first.rows).toBe(2);
+		expect(first.records.map((record) => record.split(',')[0])).toEqual([
+			'A-1',
+			'B-2',
+		]);
+		expect(first.nextCursor).not.toBeNull();
+		const second = await list.page(principal, first.nextCursor, 2);
+		expect(second.records.map((record) => record.split(',')[0])).toEqual([
+			'C-3',
+			'D-4',
+		]);
+		const third = await list.page(principal, second.nextCursor, 2);
+		expect(third.records.map((record) => record.trim())).toEqual([
+			'E-5,Item E-5,product,pcs,1000,PLN,active',
+		]);
+		expect(third.nextCursor).toBeNull();
+		expect(composition.routes.length).toBeGreaterThan(0);
+	});
+});

package/.ai/references/catalog/tests/idempotency.test.ts

@@ -11,6 +11,7 @@ import {
 	type CatalogRuntime,
 } from '../src/server/runtime.ts';
 import {
+	allItems,
 	catalogTestProvider,
 	closeCatalogTestDatabases,
 } from './support/database.ts';
@@ -117,7 +118,7 @@ describe('catalog target idempotency', () => {
 		)) as CatalogItem;
 		expect(replay).toEqual(first);
 		await expect(
-			(await recoveredRuntime.service()).list('tenant-a'),
+			allItems(await recoveredRuntime.service(), 'tenant-a'),
 		).resolves.toEqual([first]);
 		expect(
 			(
@@ -155,7 +156,7 @@ describe('catalog target idempotency', () => {
 		)) as CatalogItem;
 		expect(tenantB.tenantId).toBe('tenant-b');
 		await expect(
-			(await recoveredRuntime.service()).list('tenant-b'),
+			allItems(await recoveredRuntime.service(), 'tenant-b'),
 		).resolves.toHaveLength(1);
 	});
 
@@ -170,16 +171,16 @@ describe('catalog target idempotency', () => {
 		const actor = { kind: 'user', id: 'owner-1', label: 'Owner' } as const;
 		await (await runtime.service()).archive('tenant-a', created.id, actor);
 		await (await runtime.service()).delete('tenant-a', created.id, actor);
-		await expect((await runtime.service()).list('tenant-a')).resolves.toEqual(
-			[],
-		);
+		await expect(
+			allItems(await runtime.service(), 'tenant-a'),
+		).resolves.toEqual([]);
 
 		expect(
 			await create.execute(input, context('catalog-delete-key-1')),
 		).toEqual(created);
-		await expect((await runtime.service()).list('tenant-a')).resolves.toEqual(
-			[],
-		);
+		await expect(
+			allItems(await runtime.service(), 'tenant-a'),
+		).resolves.toEqual([]);
 		expect(
 			(
 				await (
@@ -234,9 +235,9 @@ describe('catalog target idempotency', () => {
 					context('catalog-rollback-key-1'),
 				),
 			).rejects.toThrow(/forced_ledger_failure/);
-			await expect((await runtime.service()).list('tenant-a')).resolves.toEqual(
-				[],
-			);
+			await expect(
+				allItems(await runtime.service(), 'tenant-a'),
+			).resolves.toEqual([]);
 			expect(await rowCounts(databases)).toEqual({
 				items: 0,
 				history: 0,
@@ -284,9 +285,9 @@ describe('catalog target idempotency', () => {
 				context('catalog-corrupt-key-1'),
 			),
 		).rejects.toMatchObject({ code: 'CATALOG_IDEMPOTENCY_LEDGER_CORRUPT' });
-		await expect((await recovered.service()).list('tenant-a')).resolves.toEqual(
-			[],
-		);
+		await expect(
+			allItems(await recovered.service(), 'tenant-a'),
+		).resolves.toEqual([]);
 		expect(
 			await catalogAgentTools(recovered)[1]!.execute(
 				input,

package/.ai/references/catalog/tests/list.test.ts

@@ -0,0 +1,217 @@
+import { afterAll, afterEach, describe, expect, it } from 'vitest';
+import type { CatalogItem, CatalogListSort } from '../src/domain/types.ts';
+import {
+	CatalogService,
+	FIRST_LIST_PAGE,
+	type CatalogListInput,
+} from '../src/services/catalog-service.ts';
+import { listStatement } from '../src/services/database-repository.ts';
+import {
+	closeCatalogTestDatabases,
+	createCatalogTestDatabase,
+	type CatalogTestDatabase,
+} from './support/database.ts';
+
+const ACTOR = { kind: 'user', id: 'account-1', label: 'Test user' } as const;
+
+const databases = new Set<CatalogTestDatabase>();
+
+afterEach(async () => {
+	await Promise.all([...databases].map((database) => database.dispose()));
+	databases.clear();
+});
+
+afterAll(closeCatalogTestDatabases);
+
+async function fixture(): Promise<CatalogTestDatabase> {
+	const database = await createCatalogTestDatabase();
+	databases.add(database);
+	return database;
+}
+
+/* Names collide in case and prefix, SKUs sort differently from names, and the
+   update times are spread by the mutations below, so each order is its own. */
+const SEED = [
+	['B-2', 'bolt', 'product'],
+	['A-1', 'Bolt', 'product'],
+	['C-3', 'Anchor', 'service'],
+	['D-4', 'anchor plate', 'product'],
+	['E-5', 'Washer', 'service'],
+	['F-6', 'washer_wide', 'product'],
+	['G-7', '50% nut', 'product'],
+] as const;
+
+async function seed(
+	service: CatalogService,
+	tenantId = 'tenant-a',
+): Promise<readonly CatalogItem[]> {
+	const items: CatalogItem[] = [];
+	for (const [sku, name, kind] of SEED) {
+		items.push(
+			await service.create(
+				tenantId,
+				{ sku, name, kind, unit: 'pcs', basePriceMinor: 100, currency: 'EUR' },
+				ACTOR,
+			),
+		);
+	}
+	return items;
+}
+
+/* The unbounded order, read once by the same ORDER BY the page uses. */
+async function unbounded(
+	database: CatalogTestDatabase,
+	sort: CatalogListSort,
+	direction: 'asc' | 'desc',
+	tenantId = 'tenant-a',
+): Promise<readonly string[]> {
+	const expression = {
+		name: 'lower(name)',
+		sku: 'sku_normalized',
+		updatedAt: 'updated_at',
+	}[sort];
+	const order = direction === 'asc' ? 'ASC' : 'DESC';
+	const result = await database.runtime.transaction(
+		(transaction) =>
+			transaction.query<{ id: string }>({
+				text: `SELECT id FROM catalog_items WHERE tenant_id = $1
+				       ORDER BY ${expression} ${order}, id ${order}`,
+				parameters: [tenantId],
+			}),
+		{ access: 'read', tenantId },
+	);
+	return result.rows.map((row) => row.id);
+}
+
+async function walk(
+	service: CatalogService,
+	input: Omit<CatalogListInput, 'after'>,
+): Promise<readonly string[]> {
+	const ids: string[] = [];
+	let after: CatalogListInput['after'] = null;
+	for (;;) {
+		const page = await service.listPage('tenant-a', { ...input, after });
+		ids.push(...page.items.map((item) => item.id));
+		if (page.next === null) return ids;
+		after = page.next;
+	}
+}
+
+describe('catalog list pages', () => {
+	it('walks every order in pages of two exactly as the unbounded order reads', async () => {
+		const database = await fixture();
+		const service = new CatalogService(database.repository);
+		const items = await seed(service);
+		await seed(service, 'tenant-b');
+		/* Spread the update times so the recency order differs from creation. */
+		await service.archive('tenant-a', items[2]!.id, ACTOR);
+		await service.update(
+			'tenant-a',
+			{ ...items[5]!, name: 'washer_wide', basePriceMinor: 120 },
+			ACTOR,
+		);
+		for (const sort of ['name', 'sku', 'updatedAt'] as const) {
+			for (const direction of ['asc', 'desc'] as const) {
+				const expected = await unbounded(database, sort, direction);
+				expect(expected, `${sort} ${direction}`).toHaveLength(SEED.length);
+				expect(
+					await walk(service, {
+						...FIRST_LIST_PAGE,
+						sort,
+						direction,
+						limit: 2,
+					}),
+					`${sort} ${direction}`,
+				).toEqual(expected);
+			}
+		}
+	});
+
+	it('hands a cursor back only on a full page', async () => {
+		const service = new CatalogService((await fixture()).repository);
+		await seed(service);
+		const full = await service.listPage('tenant-a', {
+			...FIRST_LIST_PAGE,
+			limit: SEED.length,
+		});
+		expect(full.items).toHaveLength(SEED.length);
+		expect(full.next).not.toBeNull();
+		const rest = await service.listPage('tenant-a', {
+			...FIRST_LIST_PAGE,
+			limit: SEED.length,
+			after: full.next,
+		});
+		expect(rest).toEqual({ items: [], next: null });
+		const short = await service.listPage('tenant-a', {
+			...FIRST_LIST_PAGE,
+			limit: SEED.length + 1,
+		});
+		expect(short.items).toHaveLength(SEED.length);
+		expect(short.next).toBeNull();
+	});
+
+	it('narrows by kind, status and a literal search in SQL', async () => {
+		const service = new CatalogService((await fixture()).repository);
+		const items = await seed(service);
+		await service.archive('tenant-a', items[0]!.id, ACTOR);
+		const skus = async (input: Partial<CatalogListInput>) =>
+			(
+				await service.listPage('tenant-a', { ...FIRST_LIST_PAGE, ...input })
+			).items.map((item) => item.sku);
+
+		expect(await skus({ kind: 'service', sort: 'sku' })).toEqual([
+			'C-3',
+			'E-5',
+		]);
+		expect(await skus({ status: 'archived' })).toEqual(['B-2']);
+		expect(
+			await skus({ status: 'active', kind: 'product', sort: 'sku' }),
+		).toEqual(['A-1', 'D-4', 'F-6', 'G-7']);
+		expect(await skus({ search: 'BOLT', sort: 'sku' })).toEqual(['A-1', 'B-2']);
+		expect(await skus({ search: 'a-1' })).toEqual(['A-1']);
+		expect(await skus({ search: '%' })).toEqual(['G-7']);
+		expect(await skus({ search: '_wide' })).toEqual(['F-6']);
+		expect(await skus({ search: 'nothing-here' })).toEqual([]);
+	});
+
+	it('refuses an unknown sort, direction, limit or filter before reading', async () => {
+		const service = new CatalogService((await fixture()).repository);
+		await expect(
+			service.listPage('tenant-a', {
+				...FIRST_LIST_PAGE,
+				sort: 'price' as CatalogListSort,
+			}),
+		).rejects.toMatchObject({ code: 'INVALID_INPUT' });
+		await expect(
+			service.listPage('tenant-a', { ...FIRST_LIST_PAGE, limit: 201 }),
+		).rejects.toMatchObject({ code: 'INVALID_INPUT' });
+		await expect(
+			service.listPage('tenant-a', {
+				...FIRST_LIST_PAGE,
+				kind: 'bundle' as CatalogItem['kind'],
+			}),
+		).rejects.toMatchObject({ code: 'INVALID_ITEM_KIND' });
+	});
+
+	it('orders by the indexed expression and binds every value', () => {
+		const statement = listStatement('tenant-a', {
+			sort: 'name',
+			direction: 'desc',
+			kind: 'product',
+			status: null,
+			term: 'bo%lt',
+			limit: 50,
+			after: { sortValue: 'bolt', id: 'item-1' },
+		});
+		expect(statement.text).toContain('ORDER BY lower(name) DESC, id DESC');
+		expect(statement.text).toContain('(lower(name), id) <');
+		expect(statement.parameters).toEqual([
+			'tenant-a',
+			'product',
+			'%bo\\%lt%',
+			'bolt',
+			'item-1',
+			50,
+		]);
+	});
+});