@rangka/core 0.0.1

package/src/api/__tests__/query-parser.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect } from 'vitest';
+import { QueryParser, QueryValidationError } from '../query-parser.js';
+import type { ResolvedField } from '../../schema/types.js';
+
+function makeFields(): ResolvedField[] {
+  return [
+    { name: 'id', config: { type: 'string' }, provenance: { source: 'base' } },
+    { name: 'status', config: { type: 'string' }, provenance: { source: 'base' } },
+    { name: 'name', config: { type: 'string' }, provenance: { source: 'base' } },
+    {
+      name: 'grand_total',
+      config: { type: 'decimal', precision: 10, scale: 2 },
+      provenance: { source: 'base' },
+    },
+    { name: 'quantity', config: { type: 'int' }, provenance: { source: 'base' } },
+    { name: 'created_at', config: { type: 'datetime' }, provenance: { source: 'base' } },
+    { name: 'is_active', config: { type: 'boolean' }, provenance: { source: 'base' } },
+    { name: 'deleted_at', config: { type: 'datetime' }, provenance: { source: 'base' } },
+    { name: 'description', config: { type: 'text' }, provenance: { source: 'base' } },
+  ];
+}
+
+const relations = ['customer', 'items'];
+
+describe('QueryParser', () => {
+  describe('parseFilters', () => {
+    it('parses equality filter', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { status: { eq: 'posted' } } });
+      expect(result).toEqual([{ field: 'status', operator: 'eq', value: 'posted' }]);
+    });
+
+    it('parses gt filter on numeric field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { grand_total: { gt: '1000' } } });
+      expect(result).toEqual([{ field: 'grand_total', operator: 'gt', value: 1000 }]);
+    });
+
+    it('parses in filter with multiple values', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { status: { in: 'draft,posted' } } });
+      expect(result).toEqual([{ field: 'status', operator: 'in', value: ['draft', 'posted'] }]);
+    });
+
+    it('parses like filter', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { name: { like: 'acme' } } });
+      expect(result).toEqual([{ field: 'name', operator: 'like', value: 'acme' }]);
+    });
+
+    it('parses isnull filter', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { deleted_at: { isnull: 'true' } } });
+      expect(result).toEqual([{ field: 'deleted_at', operator: 'isnull', value: true }]);
+    });
+
+    it('parses multiple filters', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({
+        filter: { status: { eq: 'posted' }, grand_total: { gte: '500' } },
+      });
+      expect(result).toHaveLength(2);
+    });
+
+    it('rejects unknown field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseFilters({ filter: { nonexistent: { eq: 'x' } } })).toThrow(
+        QueryValidationError,
+      );
+    });
+
+    it('rejects unknown operator', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseFilters({ filter: { status: { badop: 'x' } } })).toThrow(
+        QueryValidationError,
+      );
+    });
+
+    it('rejects gt operator on string field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseFilters({ filter: { status: { gt: '5' } } })).toThrow(
+        QueryValidationError,
+      );
+    });
+
+    it('rejects like operator on numeric field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseFilters({ filter: { grand_total: { like: 'abc' } } })).toThrow(
+        QueryValidationError,
+      );
+    });
+
+    it('allows gt on date field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFilters({ filter: { created_at: { gt: '2024-01-01' } } });
+      expect(result).toEqual([{ field: 'created_at', operator: 'gt', value: '2024-01-01' }]);
+    });
+
+    it('returns empty for missing filter param', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseFilters({})).toEqual([]);
+    });
+  });
+
+  describe('parseSort', () => {
+    it('parses ascending sort', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseSort({ sort: 'created_at' });
+      expect(result).toEqual([{ field: 'created_at', direction: 'asc' }]);
+    });
+
+    it('parses descending sort', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseSort({ sort: '-grand_total' });
+      expect(result).toEqual([{ field: 'grand_total', direction: 'desc' }]);
+    });
+
+    it('parses multiple sort fields', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseSort({ sort: 'status,-created_at' });
+      expect(result).toEqual([
+        { field: 'status', direction: 'asc' },
+        { field: 'created_at', direction: 'desc' },
+      ]);
+    });
+
+    it('rejects unknown sort field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseSort({ sort: 'nonexistent' })).toThrow(QueryValidationError);
+    });
+
+    it('returns empty for missing sort param', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseSort({})).toEqual([]);
+    });
+  });
+
+  describe('parsePagination', () => {
+    it('returns defaults when no params', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parsePagination({});
+      expect(result).toEqual({ page: 1, limit: 25, offset: 0 });
+    });
+
+    it('parses explicit page and limit', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parsePagination({ page: '2', limit: '10' });
+      expect(result).toEqual({ page: 2, limit: 10, offset: 10 });
+    });
+
+    it('caps limit at 100', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parsePagination({ limit: '500' });
+      expect(result.limit).toBe(100);
+    });
+
+    it('floors page at 1', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parsePagination({ page: '-1' });
+      expect(result.page).toBe(1);
+    });
+
+    it('floors limit at 1', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parsePagination({ limit: '0' });
+      expect(result.limit).toBe(1);
+    });
+  });
+
+  describe('parseIncludes', () => {
+    it('parses single include', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseIncludes({ include: 'customer' });
+      expect(result).toEqual([{ relation: 'customer' }]);
+    });
+
+    it('parses multiple includes', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseIncludes({ include: 'customer,items' });
+      expect(result).toEqual([{ relation: 'customer' }, { relation: 'items' }]);
+    });
+
+    it('parses nested include', () => {
+      const parser = new QueryParser(makeFields(), ['items']);
+      const result = parser.parseIncludes({ include: 'items.tax_type' });
+      expect(result).toEqual([{ relation: 'items', nested: [{ relation: 'tax_type' }] }]);
+    });
+
+    it('rejects depth > 2', () => {
+      const parser = new QueryParser(makeFields(), ['items']);
+      expect(() => parser.parseIncludes({ include: 'items.tax_type.category' })).toThrow(
+        QueryValidationError,
+      );
+    });
+
+    it('rejects unknown relation', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseIncludes({ include: 'nonexistent' })).toThrow(QueryValidationError);
+    });
+
+    it('returns empty for missing include param', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseIncludes({})).toEqual([]);
+    });
+  });
+
+  describe('parseFields', () => {
+    it('parses field list', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFields({ fields: 'id,status,grand_total' });
+      expect(result).toEqual(['id', 'status', 'grand_total']);
+    });
+
+    it('always includes id', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseFields({ fields: 'status' });
+      expect(result).toContain('id');
+      expect(result).toContain('status');
+    });
+
+    it('rejects unknown field', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(() => parser.parseFields({ fields: 'id,nonexistent' })).toThrow(QueryValidationError);
+    });
+
+    it('returns empty for missing fields param', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseFields({})).toEqual([]);
+    });
+  });
+
+  describe('parse (full)', () => {
+    it('parses combined query', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parse({
+        filter: { status: { eq: 'draft' } },
+        sort: '-created_at',
+        page: '2',
+        limit: '10',
+        include: 'customer',
+        fields: 'id,status',
+      });
+      expect(result.filters).toHaveLength(1);
+      expect(result.sort).toHaveLength(1);
+      expect(result.pagination).toEqual({ page: 2, limit: 10, offset: 10 });
+      expect(result.includes).toHaveLength(1);
+      expect(result.fields).toContain('status');
+    });
+  });
+
+  describe('parseSearch', () => {
+    it('returns trimmed string for valid search', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parseSearch({ search: '  hello  ' });
+      expect(result).toBe('hello');
+    });
+
+    it('returns undefined for empty string', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseSearch({ search: '' })).toBeUndefined();
+    });
+
+    it('returns undefined for whitespace-only string', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseSearch({ search: '   ' })).toBeUndefined();
+    });
+
+    it('returns undefined when search param is missing', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseSearch({})).toBeUndefined();
+    });
+
+    it('returns undefined for non-string values', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      expect(parser.parseSearch({ search: 123 })).toBeUndefined();
+      expect(parser.parseSearch({ search: null })).toBeUndefined();
+    });
+
+    it('is included in parse() result', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parse({ search: 'keyword' });
+      expect(result.search).toBe('keyword');
+    });
+
+    it('parse() returns undefined search when not provided', () => {
+      const parser = new QueryParser(makeFields(), relations);
+      const result = parser.parse({});
+      expect(result.search).toBeUndefined();
+    });
+  });
+});

package/src/api/__tests__/route-generator.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from 'vitest';
+import { createServer } from '../server.js';
+import { generateRoutes } from '../route-generator.js';
+import type { SchemaRegistry } from '../../schema/registry.js';
+import type { DatabaseClient } from '../../db/client.js';
+import type { ResolvedModel } from '../../schema/types.js';
+
+function makeModel(module: string, name: string): ResolvedModel {
+  return {
+    qualifiedName: `${module}.${name}`,
+    app: 'test',
+    module,
+    name,
+    auditLog: false,
+    traits: [],
+    fields: [{ name: 'id', config: { type: 'string' }, provenance: { source: 'base' } }],
+    indexes: [],
+  };
+}
+
+function makeRegistry(models: ResolvedModel[]): SchemaRegistry {
+  return {
+    getModelsByModule: () => {
+      const map = new Map<string, ResolvedModel[]>();
+      for (const m of models) {
+        const list = map.get(m.module) ?? [];
+        list.push(m);
+        map.set(m.module, list);
+      }
+      return map;
+    },
+    getRelationshipsForModel: () => [],
+    getModel: (name: string) => models.find((m) => m.qualifiedName === name) ?? null,
+  } as unknown as SchemaRegistry;
+}
+
+function makeMockDb(): DatabaseClient {
+  const buildQuery = () => {
+    const q: any = {};
+    q.select = () => q;
+    q.selectAll = () => q;
+    q.where = () => q;
+    q.orderBy = () => q;
+    q.offset = () => q;
+    q.limit = () => q;
+    q.execute = async () => [];
+    q.executeTakeFirst = async () => ({ count: '0' });
+    q.executeTakeFirstOrThrow = async () => ({});
+    q.values = () => q;
+    q.set = () => q;
+    q.returningAll = () => q;
+    return q;
+  };
+
+  return {
+    selectFrom: () => buildQuery(),
+    insertInto: () => buildQuery(),
+    updateTable: () => buildQuery(),
+    deleteFrom: () => buildQuery(),
+    kysely: { fn: { countAll: () => ({ as: () => 'count' }) } },
+  } as unknown as DatabaseClient;
+}
+
+describe('generateRoutes', () => {
+  it('registers all five CRUD routes per model', async () => {
+    const models = [makeModel('sales', 'invoice')];
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(models), makeMockDb());
+
+    const list = await server.inject({ method: 'GET', url: '/api/sales/invoice' });
+    expect(list.statusCode).toBe(200);
+    const get = await server.inject({ method: 'GET', url: '/api/sales/invoice/1' });
+    expect([200, 404]).toContain(get.statusCode);
+    const post = await server.inject({
+      method: 'POST',
+      url: '/api/sales/invoice',
+      headers: { 'content-type': 'application/json' },
+      payload: '{}',
+    });
+    expect([201, 400]).toContain(post.statusCode);
+    const put = await server.inject({
+      method: 'PUT',
+      url: '/api/sales/invoice/1',
+      headers: { 'content-type': 'application/json' },
+      payload: '{}',
+    });
+    expect([200, 404]).toContain(put.statusCode);
+    const del = await server.inject({ method: 'DELETE', url: '/api/sales/invoice/1' });
+    expect([204, 404]).toContain(del.statusCode);
+  });
+
+  it('registers routes for multiple models across modules', async () => {
+    const models = [
+      makeModel('sales', 'invoice'),
+      makeModel('sales', 'customer'),
+      makeModel('accounting', 'journal_entry'),
+    ];
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(models), makeMockDb());
+
+    const r1 = await server.inject({ method: 'GET', url: '/api/sales/invoice' });
+    expect(r1.statusCode).toBe(200);
+    const r2 = await server.inject({ method: 'GET', url: '/api/sales/customer' });
+    expect(r2.statusCode).toBe(200);
+    const r3 = await server.inject({ method: 'GET', url: '/api/accounting/journal_entry' });
+    expect(r3.statusCode).toBe(200);
+  });
+
+  it('uses correct URL pattern from qualified name', async () => {
+    const models = [makeModel('hr', 'employee')];
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(models), makeMockDb());
+
+    const listRes = await server.inject({ method: 'GET', url: '/api/hr/employee' });
+    expect(listRes.statusCode).toBe(200);
+
+    const getRes = await server.inject({ method: 'GET', url: '/api/hr/employee/123' });
+    expect([200, 404]).toContain(getRes.statusCode);
+  });
+
+  it('handles multi-word model names', async () => {
+    const models = [makeModel('sales', 'invoice_item')];
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(models), makeMockDb());
+
+    const res = await server.inject({ method: 'GET', url: '/api/sales/invoice_item' });
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('registers no routes when registry is empty', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry([]), makeMockDb());
+
+    const res = await server.inject({ method: 'GET', url: '/api/anything' });
+    expect(res.statusCode).toBe(404);
+  });
+});

package/src/api/__tests__/server.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { createServer } from '../server.js';
+
+describe('createServer', () => {
+  it('returns a Fastify instance with defaults', async () => {
+    const server = await createServer();
+    expect(server).toBeDefined();
+    expect(server.hasRoute).toBeDefined();
+  });
+
+  it('applies custom options', async () => {
+    const server = await createServer({ port: 4000, host: '0.0.0.0', logger: false });
+    expect(server).toBeDefined();
+  });
+
+  it('parses JSON bodies', async () => {
+    const server = await createServer();
+    server.post('/test', async (req) => req.body);
+
+    const res = await server.inject({
+      method: 'POST',
+      url: '/test',
+      headers: { 'content-type': 'application/json' },
+      payload: JSON.stringify({ hello: 'world' }),
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body)).toEqual({ hello: 'world' });
+  });
+
+  it('generates request IDs', async () => {
+    const server = await createServer();
+    server.get('/test', async (req) => ({ id: req.id }));
+
+    const res = await server.inject({ method: 'GET', url: '/test' });
+    const body = JSON.parse(res.body);
+    expect(body.id).toBeDefined();
+    expect(body.id).toMatch(/^[0-9a-f-]{36}$/);
+  });
+
+  it('returns structured error response', async () => {
+    const server = await createServer();
+    server.get('/fail', async () => {
+      const err = new Error('Something broke') as any;
+      err.statusCode = 422;
+      err.code = 'UNPROCESSABLE';
+      throw err;
+    });
+
+    const res = await server.inject({ method: 'GET', url: '/fail' });
+    expect(res.statusCode).toBe(422);
+    const body = JSON.parse(res.body);
+    expect(body.error.code).toBe('UNPROCESSABLE');
+    expect(body.error.message).toBe('Something broke');
+  });
+
+  it('defaults to 500 for unhandled errors', async () => {
+    const server = await createServer();
+    server.get('/crash', async () => {
+      throw new Error('Unexpected');
+    });
+
+    const res = await server.inject({ method: 'GET', url: '/crash' });
+    expect(res.statusCode).toBe(500);
+    const body = JSON.parse(res.body);
+    expect(body.error.code).toBe('INTERNAL_ERROR');
+  });
+
+  it('uses custom requestIdHeader', async () => {
+    const server = await createServer({ requestIdHeader: 'x-trace-id' });
+    expect(server).toBeDefined();
+  });
+});

package/src/api/__tests__/swagger.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest';
+import { createServer } from '../server.js';
+import { generateRoutes } from '../route-generator.js';
+import type { SchemaRegistry } from '../../schema/registry.js';
+import type { DatabaseClient } from '../../db/client.js';
+import type { ResolvedModel } from '../../schema/types.js';
+
+function makeModel(): ResolvedModel {
+  return {
+    qualifiedName: 'sales.customer',
+    app: 'test',
+    module: 'sales',
+    name: 'customer',
+    label: 'Customer',
+    auditLog: false,
+    traits: [],
+    fields: [
+      {
+        name: 'name',
+        config: { type: 'string', required: true, label: 'Customer Name' },
+        provenance: { source: 'base' },
+      },
+      {
+        name: 'email',
+        config: { type: 'string', required: true, label: 'Email' },
+        provenance: { source: 'base' },
+      },
+      {
+        name: 'status',
+        config: { type: 'enum', options: ['Active', 'Inactive'], label: 'Status' },
+        provenance: { source: 'base' },
+      },
+      {
+        name: 'balance',
+        config: { type: 'decimal', label: 'Balance' },
+        provenance: { source: 'base' },
+      },
+    ],
+    indexes: [],
+  };
+}
+
+function makeRegistry(): SchemaRegistry {
+  const model = makeModel();
+  return {
+    getModelsByModule: () => new Map([['sales', [model]]]),
+    getRelationshipsForModel: () => [],
+  } as unknown as SchemaRegistry;
+}
+
+function makeMockDb(): DatabaseClient {
+  const buildQuery = () => {
+    const q: any = {};
+    q.select = () => q;
+    q.selectAll = () => q;
+    q.where = () => q;
+    q.orderBy = () => q;
+    q.offset = () => q;
+    q.limit = () => q;
+    q.execute = async () => [];
+    q.executeTakeFirst = async () => ({ count: '0' });
+    q.executeTakeFirstOrThrow = async () => ({});
+    q.values = () => q;
+    q.set = () => q;
+    q.returningAll = () => q;
+    return q;
+  };
+
+  return {
+    selectFrom: () => buildQuery(),
+    insertInto: () => buildQuery(),
+    updateTable: () => buildQuery(),
+    deleteFrom: () => buildQuery(),
+    kysely: { fn: { countAll: () => ({ as: () => 'count' }) } },
+  } as unknown as DatabaseClient;
+}
+
+describe('Swagger API Docs', () => {
+  it('registers swagger and /api/docs/json returns valid OpenAPI document', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs/json' });
+    expect(res.statusCode).toBe(200);
+    const spec = JSON.parse(res.body);
+    expect(spec.openapi).toBe('3.1.0');
+    expect(spec.info.title).toBe('Rangka API');
+    expect(spec.paths).toBeDefined();
+  });
+
+  it('includes model fields in component schemas via route body', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs/json' });
+    const spec = JSON.parse(res.body);
+
+    const postPath = spec.paths['/api/sales/customer'];
+    expect(postPath).toBeDefined();
+    expect(postPath.post).toBeDefined();
+
+    const bodySchema = postPath.post.requestBody.content['application/json'].schema;
+    expect(bodySchema.properties.name).toEqual({ type: 'string', description: 'Customer Name' });
+    expect(bodySchema.properties.email).toEqual({ type: 'string', description: 'Email' });
+    expect(bodySchema.properties.status).toEqual({
+      type: 'string',
+      enum: ['Active', 'Inactive'],
+      description: 'Status',
+    });
+    expect(bodySchema.properties.balance).toEqual({ type: 'number', description: 'Balance' });
+  });
+
+  it('documents query parameters on list endpoints', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs/json' });
+    const spec = JSON.parse(res.body);
+
+    const listPath = spec.paths['/api/sales/customer'];
+    expect(listPath.get).toBeDefined();
+    const params = listPath.get.parameters;
+    const paramNames = params.map((p: any) => p.name);
+    expect(paramNames).toContain('page');
+    expect(paramNames).toContain('limit');
+    expect(paramNames).toContain('sort');
+    expect(paramNames).toContain('fields');
+    expect(paramNames).toContain('include');
+  });
+
+  it('does not register docs when docs: false', async () => {
+    const server = await createServer({ docs: false });
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs/json' });
+    expect(res.statusCode).toBe(404);
+  });
+
+  it('serves Swagger UI HTML at /api/docs', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs' });
+    expect(res.statusCode).toBe(200);
+    expect(res.headers['content-type']).toContain('text/html');
+    expect(res.body).toContain('swagger');
+  });
+
+  it('groups endpoints by module tag', async () => {
+    const server = await createServer({ tags: [{ name: 'sales' }] });
+    generateRoutes(server, makeRegistry(), makeMockDb());
+    await server.ready();
+
+    const res = await server.inject({ method: 'GET', url: '/api/docs/json' });
+    const spec = JSON.parse(res.body);
+
+    const listPath = spec.paths['/api/sales/customer'];
+    expect(listPath.get.tags).toContain('sales');
+    expect(listPath.post.tags).toContain('sales');
+  });
+});