@rangka/core 0.1.1 → 0.1.3

package/src/hooks/__tests__/executor.test.ts

@@ -1,433 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ValidationError } from '../errors.js';
-import { executeHookPipeline } from '../executor.js';
-import { HookRegistry } from '../registry.js';
-import type { HookDocument } from '../types.js';
-import type { SchemaRegistry } from '../../schema/registry.js';
-import type { RequestContext } from '../../auth/types.js';
-
-function mockSchema(): SchemaRegistry {
-  return {} as unknown as SchemaRegistry;
-}
-
-function mockAuth(): RequestContext {
-  return {
-    user: { id: '1', email: 'test@test.com' },
-    roles: ['Admin'],
-    scopeFilters: [],
-  } as unknown as RequestContext;
-}
-
-function mockKysely() {
-  const trxQueries: any[] = [];
-  const trx: any = {
-    insertInto: (table: string) => {
-      const q: any = {};
-      q.values = (v: any) => {
-        trxQueries.push({ op: 'insert', table, values: v });
-        return q;
-      };
-      q.returningAll = () => q;
-      q.executeTakeFirstOrThrow = async () => ({
-        id: '1',
-        ...trxQueries[trxQueries.length - 1]?.values,
-      });
-      return q;
-    },
-    updateTable: (table: string) => {
-      const q: any = {};
-      q.set = (v: any) => {
-        trxQueries.push({ op: 'update', table, values: v });
-        return q;
-      };
-      q.where = () => q;
-      q.returningAll = () => q;
-      q.executeTakeFirstOrThrow = async () => ({
-        id: '1',
-        ...trxQueries[trxQueries.length - 1]?.values,
-      });
-      return q;
-    },
-    deleteFrom: (table: string) => {
-      const q: any = {};
-      q.where = () => q;
-      q.execute = async () => {
-        trxQueries.push({ op: 'delete', table });
-      };
-      return q;
-    },
-  };
-
-  const db: any = {
-    transaction: () => ({
-      execute: async (cb: (trx: any) => Promise<any>) => cb(trx),
-    }),
-  };
-
-  return { db, trx, trxQueries };
-}
-
-describe('executeHookPipeline', () => {
-  it('runs full create pipeline: validate → beforeCreate → execute → afterCreate', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        validate: () => {
-          order.push('validate');
-        },
-        beforeCreate: async () => {
-          order.push('beforeCreate');
-        },
-        afterCreate: async () => {
-          order.push('afterCreate');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'create',
-      chain,
-      doc: { name: 'INV-001' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => {
-        order.push('execute');
-        return { id: '1', ...doc };
-      },
-    });
-
-    expect(order).toEqual(['validate', 'beforeCreate', 'execute', 'afterCreate']);
-  });
-
-  it('runs beforeSave/afterSave for create operations', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeSave: async () => {
-          order.push('beforeSave');
-        },
-        afterSave: async () => {
-          order.push('afterSave');
-        },
-        beforeCreate: async () => {
-          order.push('beforeCreate');
-        },
-        afterCreate: async () => {
-          order.push('afterCreate');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'create',
-      chain,
-      doc: { name: 'INV-001' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => ({ id: '1', ...doc }),
-    });
-
-    expect(order).toEqual(['beforeSave', 'beforeCreate', 'afterCreate', 'afterSave']);
-  });
-
-  it('validate hook rejection aborts pipeline', async () => {
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        validate: (doc) => {
-          if (!doc.customer) {
-            throw new ValidationError('customer', 'Customer is required');
-          }
-        },
-        beforeCreate: async () => {
-          throw new Error('Should not reach beforeCreate');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await expect(
-      executeHookPipeline({
-        model: 'sales.invoice',
-        operation: 'create',
-        chain,
-        doc: { name: 'INV-001' },
-        db,
-        schema: mockSchema(),
-        auth: mockAuth(),
-        execute: async (doc) => doc,
-      }),
-    ).rejects.toThrow(ValidationError);
-  });
-
-  it('beforeCreate can modify the document', async () => {
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeCreate: async (doc) => {
-          doc.computed_total = 100;
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-    let executedDoc: HookDocument | undefined;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'create',
-      chain,
-      doc: { name: 'INV-001' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => {
-        executedDoc = doc;
-        return { id: '1', ...doc };
-      },
-    });
-
-    expect(executedDoc!.computed_total).toBe(100);
-  });
-
-  it('afterCreate receives the result from execute', async () => {
-    const registry = new HookRegistry();
-    let afterDoc: HookDocument | undefined;
-    registry.register(
-      'sales.invoice',
-      {
-        afterCreate: async (doc) => {
-          afterDoc = doc;
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'create',
-      chain,
-      doc: { name: 'INV-001' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => ({ id: '1', ...doc, server_generated: true }),
-    });
-
-    expect(afterDoc!.server_generated).toBe(true);
-  });
-
-  it('rolls back transaction on beforeCreate throw', async () => {
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeCreate: async () => {
-          throw new Error('Business rule violated');
-        },
-      },
-      'sales',
-    );
-
-    let transactionRolledBack = false;
-    const db: any = {
-      transaction: () => ({
-        execute: async (cb: (trx: any) => Promise<any>) => {
-          try {
-            return await cb({});
-          } catch (err) {
-            transactionRolledBack = true;
-            throw err;
-          }
-        },
-      }),
-    };
-
-    const chain = registry.getChain('sales.invoice')!;
-
-    await expect(
-      executeHookPipeline({
-        model: 'sales.invoice',
-        operation: 'create',
-        chain,
-        doc: { name: 'INV-001' },
-        db,
-        schema: mockSchema(),
-        auth: mockAuth(),
-        execute: async (doc) => doc,
-      }),
-    ).rejects.toThrow('Business rule violated');
-
-    expect(transactionRolledBack).toBe(true);
-  });
-
-  it('extension hooks run after base hooks', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeCreate: async () => {
-          order.push('base');
-        },
-      },
-      'sales',
-    );
-    registry.register(
-      'sales.invoice',
-      {
-        beforeCreate: async () => {
-          order.push('extension');
-        },
-      },
-      'custom',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'create',
-      chain,
-      doc: {},
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => doc,
-    });
-
-    expect(order).toEqual(['base', 'extension']);
-  });
-
-  it('handles update operation with beforeUpdate/afterUpdate', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeUpdate: async () => {
-          order.push('beforeUpdate');
-        },
-        afterUpdate: async () => {
-          order.push('afterUpdate');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'update',
-      chain,
-      doc: { id: '1', name: 'INV-002' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => doc,
-    });
-
-    expect(order).toEqual(['beforeUpdate', 'afterUpdate']);
-  });
-
-  it('handles delete operation with beforeDelete/afterDelete', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeDelete: async () => {
-          order.push('beforeDelete');
-        },
-        afterDelete: async () => {
-          order.push('afterDelete');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'delete',
-      chain,
-      doc: { id: '1' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => doc,
-    });
-
-    expect(order).toEqual(['beforeDelete', 'afterDelete']);
-  });
-
-  it('does not run beforeSave/afterSave for delete operations', async () => {
-    const order: string[] = [];
-    const registry = new HookRegistry();
-    registry.register(
-      'sales.invoice',
-      {
-        beforeSave: async () => {
-          order.push('beforeSave');
-        },
-        afterSave: async () => {
-          order.push('afterSave');
-        },
-        beforeDelete: async () => {
-          order.push('beforeDelete');
-        },
-        afterDelete: async () => {
-          order.push('afterDelete');
-        },
-      },
-      'sales',
-    );
-
-    const { db } = mockKysely();
-    const chain = registry.getChain('sales.invoice')!;
-
-    await executeHookPipeline({
-      model: 'sales.invoice',
-      operation: 'delete',
-      chain,
-      doc: { id: '1' },
-      db,
-      schema: mockSchema(),
-      auth: mockAuth(),
-      execute: async (doc) => doc,
-    });
-
-    expect(order).toEqual(['beforeDelete', 'afterDelete']);
-  });
-});

package/src/hooks/__tests__/middleware.test.ts

@@ -1,224 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createServer } from '../../api/server.js';
-import { generateRoutes } from '../../api/route-generator.js';
-import { HookRegistry } from '../registry.js';
-import { ValidationError } from '../errors.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, traits: 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' } },
-    ],
-    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(store: Record<string, any> = {}): DatabaseClient {
-  const buildQuery = (op?: string) => {
-    const q: any = { _where: null, _values: null, _set: null };
-    q.select = () => q;
-    q.selectAll = () => q;
-    q.where = (_field: string, _op: string, val: any) => {
-      q._where = val;
-      return q;
-    };
-    q.orderBy = () => q;
-    q.offset = () => q;
-    q.limit = () => q;
-    q.execute = async () => {
-      return [];
-    };
-    q.executeTakeFirst = async () => {
-      if (q._where && store[q._where]) return store[q._where];
-      return { count: '0' };
-    };
-    q.executeTakeFirstOrThrow = async () => {
-      if (op === 'insert') return { id: 'new-1', ...q._values };
-      if (op === 'update') return { ...store[q._where], ...q._set };
-      return {};
-    };
-    q.values = (v: any) => {
-      q._values = v;
-      return q;
-    };
-    q.set = (v: any) => {
-      q._set = v;
-      return q;
-    };
-    q.returningAll = () => q;
-    return q;
-  };
-
-  const trxProxy: any = {
-    selectFrom: () => buildQuery(),
-    insertInto: () => buildQuery('insert'),
-    updateTable: () => buildQuery('update'),
-    deleteFrom: () => buildQuery('delete'),
-  };
-
-  return {
-    selectFrom: () => buildQuery(),
-    insertInto: () => buildQuery('insert'),
-    updateTable: () => buildQuery('update'),
-    deleteFrom: () => buildQuery('delete'),
-    kysely: {
-      fn: { countAll: () => ({ as: () => 'count' }) },
-      transaction: () => ({
-        execute: async (cb: (trx: any) => Promise<any>) => cb(trxProxy),
-      }),
-    },
-  } as unknown as DatabaseClient;
-}
-
-describe('hooks middleware integration', () => {
-  it('create with validation hook rejects invalid doc', async () => {
-    const hookRegistry = new HookRegistry();
-    hookRegistry.register(
-      'sales.invoice',
-      {
-        validate: (doc) => {
-          if (!doc.name) throw new ValidationError('name', 'Name is required');
-        },
-      },
-      'sales',
-    );
-
-    const models = [makeModel('sales', 'invoice')];
-    const server = await createServer();
-    generateRoutes(server, makeRegistry(models), makeMockDb(), { hookRegistry });
-
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/sales/invoice',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify({ name: '' }),
-    });
-
-    expect(res.statusCode).toBe(400);
-    const body = JSON.parse(res.body);
-    expect(body.error.code).toBe('VALIDATION_ERROR');
-    expect(body.error.details.field).toBe('name');
-  });
-
-  it('create succeeds when validation passes', async () => {
-    const hookRegistry = new HookRegistry();
-    hookRegistry.register(
-      'sales.invoice',
-      {
-        validate: (doc) => {
-          if (!doc.name) throw new ValidationError('name', 'Name is required');
-        },
-      },
-      'sales',
-    );
-
-    const models = [makeModel('sales', 'invoice')];
-    const server = await createServer();
-    generateRoutes(server, makeRegistry(models), makeMockDb(), { hookRegistry });
-
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/sales/invoice',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify({ name: 'INV-001' }),
-    });
-
-    expect(res.statusCode).toBe(201);
-  });
-
-  it('update with beforeUpdate modifies data', async () => {
-    const hookRegistry = new HookRegistry();
-    hookRegistry.register(
-      'sales.invoice',
-      {
-        beforeUpdate: async (doc) => {
-          doc.updated_flag = true;
-        },
-      },
-      'sales',
-    );
-
-    const store: Record<string, any> = { '1': { id: '1', name: 'INV-001' } };
-    const models = [makeModel('sales', 'invoice')];
-    const server = await createServer();
-    generateRoutes(server, makeRegistry(models), makeMockDb(store), { hookRegistry });
-
-    const res = await server.inject({
-      method: 'PUT',
-      url: '/api/sales/invoice/1',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify({ name: 'INV-002' }),
-    });
-
-    expect(res.statusCode).toBe(200);
-  });
-
-  it('delete with afterDelete runs side effect', async () => {
-    let sideEffectRan = false;
-    const hookRegistry = new HookRegistry();
-    hookRegistry.register(
-      'sales.invoice',
-      {
-        afterDelete: async () => {
-          sideEffectRan = true;
-        },
-      },
-      'sales',
-    );
-
-    const store: Record<string, any> = { '1': { id: '1', name: 'INV-001' } };
-    const models = [makeModel('sales', 'invoice')];
-    const server = await createServer();
-    generateRoutes(server, makeRegistry(models), makeMockDb(store), { hookRegistry });
-
-    const res = await server.inject({
-      method: 'DELETE',
-      url: '/api/sales/invoice/1',
-    });
-
-    expect(res.statusCode).toBe(204);
-    expect(sideEffectRan).toBe(true);
-  });
-
-  it('models without hooks use standard handlers', async () => {
-    const hookRegistry = new HookRegistry();
-    const models = [makeModel('sales', 'invoice')];
-    const server = await createServer();
-    generateRoutes(server, makeRegistry(models), makeMockDb(), { hookRegistry });
-
-    const res = await server.inject({
-      method: 'POST',
-      url: '/api/sales/invoice',
-      headers: { 'content-type': 'application/json' },
-      payload: JSON.stringify({ name: 'INV-001' }),
-    });
-
-    expect(res.statusCode).toBe(201);
-  });
-});

package/src/hooks/__tests__/registry.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { HookRegistry } from '../registry.js';
-
-describe('HookRegistry', () => {
-  it('registers base hooks and retrieves chain', () => {
-    const registry = new HookRegistry();
-    const hooks = { validate: () => {} };
-    registry.register('sales.invoice', hooks, 'sales');
-
-    const chain = registry.getChain('sales.invoice');
-    expect(chain).toBeDefined();
-    expect(chain!.entries).toHaveLength(1);
-    expect(chain!.entries[0].source).toBe('sales');
-    expect(chain!.entries[0].hooks).toBe(hooks);
-  });
-
-  it('returns undefined for unknown model', () => {
-    const registry = new HookRegistry();
-    expect(registry.getChain('unknown.model')).toBeUndefined();
-  });
-
-  it('hasHooks returns false for unknown model', () => {
-    const registry = new HookRegistry();
-    expect(registry.hasHooks('unknown.model')).toBe(false);
-  });
-
-  it('merges extension hooks after base in registration order', () => {
-    const registry = new HookRegistry();
-    const baseHooks = { beforeCreate: async () => {} };
-    const extHooks = { beforeCreate: async () => {} };
-
-    registry.register('sales.invoice', baseHooks, 'sales');
-    registry.register('sales.invoice', extHooks, 'custom');
-
-    const chain = registry.getChain('sales.invoice');
-    expect(chain!.entries).toHaveLength(2);
-    expect(chain!.entries[0].source).toBe('sales');
-    expect(chain!.entries[1].source).toBe('custom');
-  });
-
-  it('maintains app dependency order across multiple extensions', () => {
-    const registry = new HookRegistry();
-    registry.register('sales.invoice', { validate: () => {} }, 'sales');
-    registry.register('sales.invoice', { validate: () => {} }, 'addon_a');
-    registry.register('sales.invoice', { validate: () => {} }, 'addon_b');
-
-    const chain = registry.getChain('sales.invoice');
-    expect(chain!.entries.map((e) => e.source)).toEqual(['sales', 'addon_a', 'addon_b']);
-  });
-});