@rangka/core 0.1.1 → 0.1.3

package/src/__tests__/widgets.test.ts

@@ -1,197 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest';
-import { WidgetRegistry } from '../widgets/widget-registry.js';
-import { validatePageBody } from '../widgets/slot-validator.js';
-import type { WidgetDefinitionMeta, WidgetNode } from '@rangka/shared';
-
-const buttonMeta: WidgetDefinitionMeta = {
-  name: 'button',
-  label: 'Button',
-  category: 'action',
-  schema: { label: { type: 'string', required: true } },
-  binding: 'none',
-  triggers: ['click'],
-  container: false,
-};
-
-const inputMeta: WidgetDefinitionMeta = {
-  name: 'input',
-  label: 'Input',
-  category: 'input',
-  schema: { label: { type: 'string' } },
-  binding: 'field',
-  triggers: ['change', 'focus', 'blur'],
-  container: false,
-};
-
-const groupMeta: WidgetDefinitionMeta = {
-  name: 'group',
-  label: 'Group',
-  category: 'layout',
-  schema: { direction: { type: 'enum', options: ['row', 'column'] } },
-  binding: 'none',
-  triggers: [],
-  container: true,
-};
-
-const tableMeta: WidgetDefinitionMeta = {
-  name: 'table',
-  label: 'Table',
-  category: 'layout',
-  schema: {},
-  binding: 'model',
-  triggers: ['rowClick'],
-  container: true,
-  accepts: ['column'],
-};
-
-const columnMeta: WidgetDefinitionMeta = {
-  name: 'column',
-  label: 'Column',
-  category: 'layout',
-  schema: { label: { type: 'string', required: true } },
-  binding: 'none',
-  triggers: [],
-  container: true,
-};
-
-describe('WidgetRegistry', () => {
-  let registry: WidgetRegistry;
-
-  beforeEach(() => {
-    registry = new WidgetRegistry();
-  });
-
-  test('registers and retrieves a widget', () => {
-    registry.register(buttonMeta);
-    expect(registry.get('button')).toEqual(buttonMeta);
-  });
-
-  test('has returns true for registered widget', () => {
-    registry.register(buttonMeta);
-    expect(registry.has('button')).toBe(true);
-  });
-
-  test('has returns false for unregistered widget', () => {
-    expect(registry.has('nonexistent')).toBe(false);
-  });
-
-  test('get returns undefined for unregistered widget', () => {
-    expect(registry.get('nonexistent')).toBeUndefined();
-  });
-
-  test('throws on duplicate registration', () => {
-    registry.register(buttonMeta);
-    expect(() => registry.register(buttonMeta)).toThrow("Widget 'button' is already registered");
-  });
-
-  test('getAll returns all registered widgets', () => {
-    registry.register(buttonMeta);
-    registry.register(inputMeta);
-    expect(registry.getAll()).toHaveLength(2);
-  });
-
-  test('names returns all widget names', () => {
-    registry.register(buttonMeta);
-    registry.register(inputMeta);
-    expect(registry.names().sort()).toEqual(['button', 'input']);
-  });
-
-  test('clear removes all widgets', () => {
-    registry.register(buttonMeta);
-    registry.clear();
-    expect(registry.has('button')).toBe(false);
-    expect(registry.getAll()).toHaveLength(0);
-  });
-});
-
-describe('validatePageBody', () => {
-  let widgetRegistry: WidgetRegistry;
-
-  beforeEach(() => {
-    widgetRegistry = new WidgetRegistry();
-    widgetRegistry.register(buttonMeta);
-    widgetRegistry.register(inputMeta);
-    widgetRegistry.register(groupMeta);
-    widgetRegistry.register(tableMeta);
-    widgetRegistry.register(columnMeta);
-  });
-
-  test('valid body produces no errors', () => {
-    const body: WidgetNode[] = [
-      { type: 'input', bind: { field: 'name' } },
-      { type: 'button', props: { label: 'Save' }, on: { click: { type: 'navigate', path: '/' } } },
-    ];
-    expect(validatePageBody(body, widgetRegistry)).toEqual([]);
-  });
-
-  test('empty body is valid', () => {
-    expect(validatePageBody([], widgetRegistry)).toEqual([]);
-  });
-
-  test('reports unknown widget type', () => {
-    const body: WidgetNode[] = [{ type: 'unknown_widget' }];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].path).toBe('body[0]');
-    expect(errors[0].message).toContain('Unknown widget type');
-  });
-
-  test('reports children on non-container', () => {
-    const body: WidgetNode[] = [
-      { type: 'button', props: { label: 'x' }, children: [{ type: 'input' }] },
-    ];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors.some((e) => e.message.includes('not a container'))).toBe(true);
-  });
-
-  test('reports disallowed child type', () => {
-    const body: WidgetNode[] = [
-      {
-        type: 'table',
-        bind: { model: { name: 'test' } },
-        children: [{ type: 'button', props: { label: 'bad' } }],
-      },
-    ];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors.some((e) => e.message.includes('does not accept child type'))).toBe(true);
-  });
-
-  test('reports unknown trigger', () => {
-    const body: WidgetNode[] = [
-      { type: 'button', props: { label: 'x' }, on: { hover: { type: 'navigate', path: '/' } } },
-    ];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors.some((e) => e.message.includes("Unknown trigger 'hover'"))).toBe(true);
-  });
-
-  test('reports invalid binding mode', () => {
-    const body: WidgetNode[] = [{ type: 'button', props: { label: 'x' }, bind: { field: 'name' } }];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors.some((e) => e.message.includes('does not support data binding'))).toBe(true);
-  });
-
-  test('validates nested children recursively', () => {
-    const body: WidgetNode[] = [
-      {
-        type: 'group',
-        children: [
-          {
-            type: 'group',
-            children: [{ type: 'nonexistent' }],
-          },
-        ],
-      },
-    ];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].path).toContain('children');
-  });
-
-  test('validates multiple top-level widgets independently', () => {
-    const body: WidgetNode[] = [{ type: 'unknown1' }, { type: 'unknown2' }];
-    const errors = validatePageBody(body, widgetRegistry);
-    expect(errors).toHaveLength(2);
-    expect(errors[0].path).toBe('body[0]');
-    expect(errors[1].path).toBe('body[1]');
-  });
-});

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

@@ -1,389 +0,0 @@
-import { describe, it, expect, vi, beforeEach } 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' } },
-      { name: 'name', config: { type: 'string', required: true }, provenance: { source: 'base' } },
-      {
-        name: 'amount',
-        config: { type: 'decimal', precision: 10, scale: 2 },
-        provenance: { source: 'base' },
-      },
-    ],
-    indexes: [],
-  };
-}
-
-function makeSoftDeleteModel(module: string, name: string): ResolvedModel {
-  return {
-    ...makeModel(module, name),
-    traits: ['soft_delete'],
-    fields: [
-      ...makeModel(module, name).fields,
-      {
-        name: 'archived_at',
-        config: { type: 'datetime' },
-        provenance: { source: 'trait', trait: 'soft_delete' },
-      },
-    ],
-  };
-}
-
-function makeRegistry(models: ResolvedModel[]): SchemaRegistry {
-  const modelMap = new Map<string, ResolvedModel>();
-  for (const m of models) modelMap.set(m.qualifiedName, m);
-
-  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: (qn: string) => modelMap.get(qn),
-    getAllModels: () => models,
-    getFieldsForModel: (qn: string) => modelMap.get(qn)?.fields ?? [],
-  } as unknown as SchemaRegistry;
-}
-
-function makeMockDb(): DatabaseClient {
-  const records: Record<string, any[]> = {};
-
-  function applyWhereFilters(data: any[], wheres: any[]): any[] {
-    for (const w of wheres) {
-      if (w.op === '=' && w.field !== 'id') {
-        data = data.filter((r) => r[w.field] === w.value);
-      } else if (w.op === 'is' && w.value === null) {
-        data = data.filter((r) => r[w.field] == null);
-      }
-    }
-    return data;
-  }
-
-  const buildQuery = (table: string) => {
-    const q: any = {
-      _table: table,
-      _wheres: [] as any[],
-      _selects: [] as string[],
-      _selectAll: false,
-      _offset: 0,
-      _limit: 25,
-    };
-    q.select = vi.fn((...args: any[]) => {
-      q._selects.push(...args);
-      return q;
-    });
-    q.selectAll = vi.fn(() => {
-      q._selectAll = true;
-      return q;
-    });
-    q.where = vi.fn((field: string, op: string, value: any) => {
-      q._wheres.push({ field, op, value });
-      return q;
-    });
-    q.orderBy = vi.fn(() => q);
-    q.offset = vi.fn((n: number) => {
-      q._offset = n;
-      return q;
-    });
-    q.limit = vi.fn((n: number) => {
-      q._limit = n;
-      return q;
-    });
-    q.execute = vi.fn(async () => {
-      let data = records[table] ?? [];
-      data = applyWhereFilters(data, q._wheres);
-      return data.slice(q._offset, q._offset + q._limit);
-    });
-    q.executeTakeFirst = vi.fn(async () => {
-      const idFilter = q._wheres.find((w: any) => w.field === 'id');
-      if (idFilter) {
-        let data = records[table] ?? [];
-        data = applyWhereFilters(data, q._wheres);
-        return data.find((r: any) => r.id === idFilter.value);
-      }
-      let data = records[table] ?? [];
-      data = applyWhereFilters(data, q._wheres);
-      return { count: String(data.length) };
-    });
-    q.executeTakeFirstOrThrow = vi.fn(async () => {
-      const result = await q.executeTakeFirst();
-      if (!result) throw new Error('No result');
-      return result;
-    });
-    q.values = vi.fn((body: any) => {
-      const rec = { id: 'new-id', ...body };
-      if (!records[table]) records[table] = [];
-      records[table].push(rec);
-      return q;
-    });
-    q.set = vi.fn((body: any) => {
-      const idFilter = q._wheres.find((w: any) => w.field === 'id');
-      if (idFilter) {
-        const data = records[table] ?? [];
-        const idx = data.findIndex((r: any) => r.id === idFilter.value);
-        if (idx >= 0) data[idx] = { ...data[idx], ...body };
-      }
-      return q;
-    });
-    q.returningAll = vi.fn(() => q);
-    return q;
-  };
-
-  const db: any = {
-    selectFrom: vi.fn((model: string) => buildQuery(model)),
-    insertInto: vi.fn((model: string) => buildQuery(model)),
-    updateTable: vi.fn((model: string) => buildQuery(model)),
-    deleteFrom: vi.fn((model: string) => buildQuery(model)),
-    kysely: { fn: { countAll: () => ({ as: (alias: string) => `count_${alias}` }) } },
-    _records: records,
-  };
-
-  return db as unknown as DatabaseClient;
-}
-
-describe('CRUD handlers via route generation', () => {
-  let server: Awaited<ReturnType<typeof createServer>>;
-  let db: ReturnType<typeof makeMockDb>;
-  let registry: ReturnType<typeof makeRegistry>;
-
-  beforeEach(async () => {
-    const models = [makeModel('sales', 'invoice')];
-    registry = makeRegistry(models);
-    db = makeMockDb();
-    server = await createServer();
-    generateRoutes(server, registry, db);
-  });
-
-  describe('GET /api/sales/invoice (list)', () => {
-    it('returns paginated response', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100 },
-        { id: '2', name: 'INV-002', amount: 200 },
-      ];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice' });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data).toBeDefined();
-      expect(body.meta).toBeDefined();
-      expect(body.meta.page).toBe(1);
-      expect(body.meta.limit).toBe(25);
-    });
-
-    it('returns 400 for invalid filter field', async () => {
-      const res = await server.inject({
-        method: 'GET',
-        url: '/api/sales/invoice?filter[nonexistent][eq]=x',
-      });
-      expect(res.statusCode).toBe(400);
-      const body = JSON.parse(res.body);
-      expect(body.error.code).toBe('QUERY_VALIDATION_ERROR');
-    });
-  });
-
-  describe('GET /api/sales/invoice/:id (get)', () => {
-    it('returns record when found', async () => {
-      (db as any)._records['sales.invoice'] = [{ id: '1', name: 'INV-001', amount: 100 }];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data.id).toBe('1');
-    });
-
-    it('returns 404 when not found', async () => {
-      (db as any)._records['sales.invoice'] = [];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice/missing' });
-      expect(res.statusCode).toBe(404);
-      const body = JSON.parse(res.body);
-      expect(body.error.code).toBe('NOT_FOUND');
-    });
-  });
-
-  describe('POST /api/sales/invoice (create)', () => {
-    it('creates record and returns 201', async () => {
-      const res = await server.inject({
-        method: 'POST',
-        url: '/api/sales/invoice',
-        headers: { 'content-type': 'application/json' },
-        payload: JSON.stringify({ name: 'INV-003', amount: 500 }),
-      });
-      expect(res.statusCode).toBe(201);
-      const body = JSON.parse(res.body);
-      expect(body.data).toBeDefined();
-    });
-
-    it('returns 400 for missing required field', async () => {
-      const res = await server.inject({
-        method: 'POST',
-        url: '/api/sales/invoice',
-        headers: { 'content-type': 'application/json' },
-        payload: JSON.stringify({ amount: 500 }),
-      });
-      expect(res.statusCode).toBe(400);
-      const body = JSON.parse(res.body);
-      expect(body.error.code).toBe('VALIDATION_ERROR');
-      expect(body.error.details).toContain('name');
-    });
-
-    it('returns 400 for empty body', async () => {
-      const res = await server.inject({
-        method: 'POST',
-        url: '/api/sales/invoice',
-        headers: { 'content-type': 'application/json' },
-        payload: '',
-      });
-      expect(res.statusCode).toBeGreaterThanOrEqual(400);
-    });
-  });
-
-  describe('PUT /api/sales/invoice/:id (update)', () => {
-    it('updates record when found', async () => {
-      (db as any)._records['sales.invoice'] = [{ id: '1', name: 'INV-001', amount: 100 }];
-
-      const res = await server.inject({
-        method: 'PUT',
-        url: '/api/sales/invoice/1',
-        headers: { 'content-type': 'application/json' },
-        payload: JSON.stringify({ amount: 999 }),
-      });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data).toBeDefined();
-    });
-
-    it('returns 404 when record not found', async () => {
-      (db as any)._records['sales.invoice'] = [];
-
-      const res = await server.inject({
-        method: 'PUT',
-        url: '/api/sales/invoice/missing',
-        headers: { 'content-type': 'application/json' },
-        payload: JSON.stringify({ amount: 999 }),
-      });
-      expect(res.statusCode).toBe(404);
-    });
-  });
-
-  describe('DELETE /api/sales/invoice/:id (delete)', () => {
-    it('returns 204 when record exists', async () => {
-      (db as any)._records['sales.invoice'] = [{ id: '1', name: 'INV-001', amount: 100 }];
-
-      const res = await server.inject({ method: 'DELETE', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(204);
-      expect(res.body).toBe('');
-    });
-
-    it('returns 404 when record not found', async () => {
-      (db as any)._records['sales.invoice'] = [];
-
-      const res = await server.inject({ method: 'DELETE', url: '/api/sales/invoice/missing' });
-      expect(res.statusCode).toBe(404);
-    });
-  });
-});
-
-describe('Soft-delete behavior', () => {
-  let server: Awaited<ReturnType<typeof createServer>>;
-  let db: ReturnType<typeof makeMockDb>;
-  let registry: ReturnType<typeof makeRegistry>;
-
-  beforeEach(async () => {
-    const models = [makeSoftDeleteModel('sales', 'invoice')];
-    registry = makeRegistry(models);
-    db = makeMockDb();
-    server = await createServer();
-    generateRoutes(server, registry, db);
-  });
-
-  describe('DELETE with soft_delete trait', () => {
-    it('sets archived_at instead of deleting the record', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: null },
-      ];
-
-      const res = await server.inject({ method: 'DELETE', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(204);
-      expect(db.updateTable).toHaveBeenCalledWith('sales.invoice');
-      expect(db.deleteFrom).not.toHaveBeenCalled();
-    });
-
-    it('returns 404 for already-archived record', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: '2026-01-01T00:00:00.000Z' },
-      ];
-
-      const res = await server.inject({ method: 'DELETE', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(404);
-    });
-  });
-
-  describe('GET list with soft_delete trait', () => {
-    it('excludes archived records by default', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: null },
-        { id: '2', name: 'INV-002', amount: 200, archived_at: '2026-01-01T00:00:00.000Z' },
-      ];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice' });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data.every((r: any) => r.archived_at === null)).toBe(true);
-    });
-
-    it('includes archived records when includeArchived=true', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: null },
-        { id: '2', name: 'INV-002', amount: 200, archived_at: '2026-01-01T00:00:00.000Z' },
-      ];
-
-      const res = await server.inject({
-        method: 'GET',
-        url: '/api/sales/invoice?includeArchived=true',
-      });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data).toHaveLength(2);
-    });
-  });
-
-  describe('GET by ID with soft_delete trait', () => {
-    it('returns 404 for archived record', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: '2026-01-01T00:00:00.000Z' },
-      ];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('returns active record normally', async () => {
-      (db as any)._records['sales.invoice'] = [
-        { id: '1', name: 'INV-001', amount: 100, archived_at: null },
-      ];
-
-      const res = await server.inject({ method: 'GET', url: '/api/sales/invoice/1' });
-      expect(res.statusCode).toBe(200);
-      const body = JSON.parse(res.body);
-      expect(body.data.id).toBe('1');
-    });
-  });
-});