@rangka/core 0.1.1 → 0.1.3

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

@@ -1,291 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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');
-  });
-});