@rangka/core 0.0.1

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

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

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

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