@rangka/core 0.1.1 → 0.1.3

package/src/model-api/__tests__/include-resolver.test.ts

@@ -1,226 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { resolveModelIncludes } from '../include-resolver.js';
-import type { SchemaRegistry } from '../../schema/registry.js';
-import type { ModelRelationship } from '../../schema/types.js';
-
-function makeRegistry(relationships: ModelRelationship[]): SchemaRegistry {
-  return {
-    getRelationshipsForModel: (model: string) => relationships.filter((r) => r.from === model),
-    getModel: (qn: string) => ({ qualifiedName: qn }),
-    getAllModels: () => [],
-    getFieldsForModel: () => [],
-  } as unknown as SchemaRegistry;
-}
-
-function makeMockDb(tables: Record<string, any[]>) {
-  const db: any = {
-    selectFrom: vi.fn((table: string) => {
-      const q: any = {
-        _table: table,
-        _wheres: [] as any[],
-      };
-      q.selectAll = vi.fn((..._args: any[]) => q);
-      q.select = vi.fn(() => q);
-      q.innerJoin = vi.fn(() => q);
-      q.where = vi.fn((field: string, op: string, value: any) => {
-        q._wheres.push({ field, op, value });
-        return q;
-      });
-      q.execute = vi.fn(async () => {
-        const tableData = tables[table] ?? [];
-        const inFilter = q._wheres.find((w: any) => w.op === 'in');
-        if (inFilter) {
-          return tableData.filter((row: any) => {
-            const fieldName = inFilter.field.includes('.')
-              ? inFilter.field.split('.').pop()
-              : inFilter.field;
-            return inFilter.value.includes(row[fieldName]);
-          });
-        }
-        return tableData;
-      });
-      return q;
-    }),
-  };
-  return db;
-}
-
-describe('resolveModelIncludes', () => {
-  describe('link relationship', () => {
-    it('resolves link by collecting IDs and batch-fetching', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({
-        billing__Customer: [
-          { id: 'c1', name: 'Acme' },
-          { id: 'c2', name: 'Beta' },
-        ],
-      });
-
-      const records = [
-        { id: 'o1', customer: 'c1' },
-        { id: 'o2', customer: 'c2' },
-        { id: 'o3', customer: 'c1' },
-      ];
-
-      await resolveModelIncludes(records, ['customer'], registry, db, 'sales.Order');
-
-      expect(records[0].customer).toEqual({ id: 'c1', name: 'Acme' });
-      expect(records[1].customer).toEqual({ id: 'c2', name: 'Beta' });
-      expect(records[2].customer).toEqual({ id: 'c1', name: 'Acme' });
-    });
-
-    it('sets null when link ID is null', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({ billing__Customer: [] });
-
-      const records = [{ id: 'o1', customer: null }];
-      await resolveModelIncludes(records, ['customer'], registry, db, 'sales.Order');
-
-      expect(records[0].customer).toBeNull();
-    });
-
-    it('sets null when referenced record does not exist', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({ billing__Customer: [] });
-
-      const records = [{ id: 'o1', customer: 'non-existent' }];
-      await resolveModelIncludes(records, ['customer'], registry, db, 'sales.Order');
-
-      expect(records[0].customer).toBeNull();
-    });
-
-    it('deduplicates IDs for batch fetch', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({
-        billing__Customer: [{ id: 'c1', name: 'Acme' }],
-      });
-
-      const records = [
-        { id: 'o1', customer: 'c1' },
-        { id: 'o2', customer: 'c1' },
-        { id: 'o3', customer: 'c1' },
-      ];
-
-      await resolveModelIncludes(records, ['customer'], registry, db, 'sales.Order');
-
-      expect(db.selectFrom).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('hasMany relationship', () => {
-    it('resolves hasMany by fetching children by foreign key', async () => {
-      const relationships: ModelRelationship[] = [
-        {
-          type: 'hasMany',
-          from: 'sales.Order',
-          field: 'lineItems',
-          to: 'sales.LineItem',
-          foreignKey: 'order_id',
-        },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({
-        sales__LineItem: [
-          { id: 'li1', order_id: 'o1', product: 'Widget' },
-          { id: 'li2', order_id: 'o1', product: 'Gadget' },
-          { id: 'li3', order_id: 'o2', product: 'Thingy' },
-        ],
-      });
-
-      const records: any[] = [
-        { id: 'o1', status: 'confirmed' },
-        { id: 'o2', status: 'draft' },
-      ];
-
-      await resolveModelIncludes(records, ['lineItems'], registry, db, 'sales.Order');
-
-      expect(records[0].lineItems).toHaveLength(2);
-      expect(records[1].lineItems).toHaveLength(1);
-      expect(records[0].lineItems[0].product).toBe('Widget');
-    });
-
-    it('returns empty array when no children exist', async () => {
-      const relationships: ModelRelationship[] = [
-        {
-          type: 'hasMany',
-          from: 'sales.Order',
-          field: 'lineItems',
-          to: 'sales.LineItem',
-          foreignKey: 'order_id',
-        },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({ sales__LineItem: [] });
-
-      const records: any[] = [{ id: 'o1', status: 'confirmed' }];
-      await resolveModelIncludes(records, ['lineItems'], registry, db, 'sales.Order');
-
-      expect(records[0].lineItems).toEqual([]);
-    });
-  });
-
-  describe('unknown relation', () => {
-    it('silently skips unknown relation names', async () => {
-      const registry = makeRegistry([]);
-      const db = makeMockDb({});
-
-      const records = [{ id: 'o1', name: 'Test' }];
-      await resolveModelIncludes(records, ['nonExistent'], registry, db, 'sales.Order');
-
-      expect(records[0]).toEqual({ id: 'o1', name: 'Test' });
-    });
-  });
-
-  describe('empty records', () => {
-    it('does nothing when records array is empty', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({});
-
-      const records: any[] = [];
-      await resolveModelIncludes(records, ['customer'], registry, db, 'sales.Order');
-
-      expect(db.selectFrom).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('multiple includes', () => {
-    it('resolves multiple relations on same records', async () => {
-      const relationships: ModelRelationship[] = [
-        { type: 'link', from: 'sales.Order', field: 'customer', to: 'billing.Customer' },
-        {
-          type: 'hasMany',
-          from: 'sales.Order',
-          field: 'lineItems',
-          to: 'sales.LineItem',
-          foreignKey: 'order_id',
-        },
-      ];
-      const registry = makeRegistry(relationships);
-      const db = makeMockDb({
-        billing__Customer: [{ id: 'c1', name: 'Acme' }],
-        sales__LineItem: [{ id: 'li1', order_id: 'o1', product: 'Widget' }],
-      });
-
-      const records: any[] = [{ id: 'o1', customer: 'c1' }];
-      await resolveModelIncludes(records, ['customer', 'lineItems'], registry, db, 'sales.Order');
-
-      expect(records[0].customer).toEqual({ id: 'c1', name: 'Acme' });
-      expect(records[0].lineItems).toHaveLength(1);
-    });
-  });
-});

package/src/model-api/__tests__/model-access.test.ts

@@ -1,284 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createModelAccess } from '../index.js';
-import type { SchemaRegistry } from '../../schema/registry.js';
-import type { ResolvedModel } from '../../schema/types.js';
-import type { RequestContext } from '../../auth/types.js';
-
-function makeModel(qualifiedName: string, traits: string[] = []): ResolvedModel {
-  return {
-    qualifiedName,
-    app: 'test',
-    module: qualifiedName.split('.')[0],
-    name: qualifiedName.split('.')[1],
-    auditLog: false,
-    traits,
-    fields: [
-      { name: 'id', config: { type: 'uuid' }, provenance: { source: 'base' } },
-      { name: 'name', config: { type: 'string', required: true }, provenance: { source: 'base' } },
-      { name: 'status', config: { type: 'string' }, provenance: { source: 'base' } },
-    ],
-    indexes: [],
-  } as ResolvedModel;
-}
-
-function makeRegistry(models: ResolvedModel[]): SchemaRegistry {
-  return {
-    getModel: (qn: string) => models.find((m) => m.qualifiedName === qn),
-    getAllModels: () => models,
-    getRelationshipsForModel: () => [],
-    getFieldsForModel: (qn: string) => models.find((m) => m.qualifiedName === qn)?.fields ?? [],
-  } as unknown as SchemaRegistry;
-}
-
-function makeMockDb() {
-  const rows = [
-    { id: 'r1', name: 'Record 1', status: 'active' },
-    { id: 'r2', name: 'Record 2', status: 'draft' },
-    { id: 'r3', name: 'Record 3', status: 'active' },
-  ];
-
-  const db: any = {
-    selectFrom: vi.fn(() => {
-      const q: any = { _wheres: [] as any[], _limit: undefined, _offset: undefined };
-      q.selectAll = vi.fn(() => q);
-      q.select = vi.fn(() => 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.limit = vi.fn((n: number) => {
-        q._limit = n;
-        return q;
-      });
-      q.offset = vi.fn((n: number) => {
-        q._offset = n;
-        return q;
-      });
-      q.execute = vi.fn(async () => {
-        let result = [...rows];
-        for (const w of q._wheres) {
-          if (w.op === '=') result = result.filter((r: any) => r[w.field] === w.value);
-          if (w.op === 'in') result = result.filter((r: any) => w.value.includes(r[w.field]));
-        }
-        if (q._limit !== undefined) result = result.slice(0, q._limit);
-        return result;
-      });
-      q.executeTakeFirst = vi.fn(async () => {
-        const result = await q.execute();
-        return result[0] ?? null;
-      });
-      q.compile = vi.fn(() => ({ sql: '', parameters: [] }));
-      return q;
-    }),
-    insertInto: vi.fn(() => {
-      const q: any = {};
-      q.values = vi.fn((_data: any) => q);
-      q.returningAll = vi.fn(() => q);
-      q.executeTakeFirstOrThrow = vi.fn(async () => ({ ...rows[0], id: 'new-id' }));
-      return q;
-    }),
-    updateTable: vi.fn(() => {
-      const q: any = {};
-      q.set = vi.fn(() => q);
-      q.where = vi.fn(() => q);
-      q.returningAll = vi.fn(() => q);
-      q.executeTakeFirstOrThrow = vi.fn(async () => ({
-        id: 'r1',
-        name: 'Updated',
-        status: 'active',
-      }));
-      q.execute = vi.fn(async () => {});
-      return q;
-    }),
-    deleteFrom: vi.fn(() => {
-      const q: any = {};
-      q.where = vi.fn(() => q);
-      q.execute = vi.fn(async () => {});
-      return q;
-    }),
-  };
-  return db;
-}
-
-describe('createModelAccess', () => {
-  const model = makeModel('sales.Order');
-  const registry = makeRegistry([model]);
-
-  it('returns an object with get, query, create, update, delete', () => {
-    const db = makeMockDb();
-    const access = createModelAccess({ db, registry });
-
-    expect(access.get).toBeTypeOf('function');
-    expect(access.query).toBeTypeOf('function');
-    expect(access.create).toBeTypeOf('function');
-    expect(access.update).toBeTypeOf('function');
-    expect(access.delete).toBeTypeOf('function');
-  });
-
-  describe('get', () => {
-    it('returns a single record by id', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      const result = await access.get('sales.Order', 'r1');
-      expect(result).toEqual({ id: 'r1', name: 'Record 1', status: 'active' });
-    });
-
-    it('returns null when record not found', async () => {
-      const db = makeMockDb();
-      db.selectFrom = vi.fn(() => {
-        const q: any = {};
-        q.selectAll = vi.fn(() => q);
-        q.where = vi.fn(() => q);
-        q.executeTakeFirst = vi.fn(async () => null);
-        return q;
-      });
-      const access = createModelAccess({ db, registry });
-
-      const result = await access.get('sales.Order', 'non-existent');
-      expect(result).toBeNull();
-    });
-
-    it('throws when model is not found in registry', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      await expect(access.get('unknown.Model', 'r1')).rejects.toThrow(/model not found/i);
-    });
-  });
-
-  describe('query', () => {
-    it('returns a chainable query builder', () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      const q = access.query('sales.Order');
-      expect(q.filter).toBeTypeOf('function');
-      expect(q.sort).toBeTypeOf('function');
-      expect(q.limit).toBeTypeOf('function');
-      expect(q.offset).toBeTypeOf('function');
-      expect(q.include).toBeTypeOf('function');
-      expect(q.fields).toBeTypeOf('function');
-      expect(q.exec).toBeTypeOf('function');
-      expect(q.first).toBeTypeOf('function');
-      expect(q.count).toBeTypeOf('function');
-    });
-
-    it('throws when model is not found in registry', () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      expect(() => access.query('unknown.Model')).toThrow(/model not found/i);
-    });
-  });
-
-  describe('create', () => {
-    it('creates a record and returns it', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      const result = await access.create('sales.Order', { name: 'New Order' });
-      expect(result).toBeDefined();
-      expect(result.id).toBe('new-id');
-    });
-
-    it('throws when model is not found', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      await expect(access.create('unknown.Model', { name: 'X' })).rejects.toThrow(
-        /model not found/i,
-      );
-    });
-
-    it('throws when required fields are missing at DB level', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      // Required field validation is now the caller's responsibility (handlers/middleware).
-      // ModelOps no longer validates — it trusts pre-validated data.
-      const result = await access.create('sales.Order', { status: 'draft' });
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('update', () => {
-    it('updates a record and returns it', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      const result = await access.update('sales.Order', 'r1', { name: 'Updated' });
-      expect(result).toBeDefined();
-      expect(result.id).toBe('r1');
-    });
-
-    it('throws when model is not found', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      await expect(access.update('unknown.Model', 'r1', { name: 'X' })).rejects.toThrow(
-        /model not found/i,
-      );
-    });
-  });
-
-  describe('delete', () => {
-    it('deletes a record and returns it', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      const result = await access.delete('sales.Order', 'r1');
-      expect(result).toBeDefined();
-      expect(result.id).toBe('r1');
-    });
-
-    it('throws when model is not found', async () => {
-      const db = makeMockDb();
-      const access = createModelAccess({ db, registry });
-
-      await expect(access.delete('unknown.Model', 'r1')).rejects.toThrow(/model not found/i);
-    });
-  });
-
-  describe('auth context passthrough', () => {
-    it('passes auth to ModelOps (stamping is caller responsibility)', async () => {
-      const timestampedModel = makeModel('sales.Order');
-      timestampedModel.traits = ['timestamped'];
-      timestampedModel.fields.push(
-        {
-          name: 'created_at',
-          config: { type: 'datetime' },
-          provenance: { source: 'trait' as const, trait: 'timestamped' },
-        } as any,
-        {
-          name: 'updated_at',
-          config: { type: 'datetime' },
-          provenance: { source: 'trait' as const, trait: 'timestamped' },
-        } as any,
-        {
-          name: 'created_by',
-          config: { type: 'uuid' },
-          provenance: { source: 'trait' as const, trait: 'timestamped' },
-        } as any,
-        {
-          name: 'updated_by',
-          config: { type: 'uuid' },
-          provenance: { source: 'trait' as const, trait: 'timestamped' },
-        } as any,
-      );
-      const tsRegistry = makeRegistry([timestampedModel]);
-
-      const db = makeMockDb();
-      const auth: RequestContext = {
-        user: { id: 'u1', email: 'a@b.c', full_name: 'A', enabled: true, password_hash: '' },
-      };
-      const access = createModelAccess({ db, registry: tsRegistry, auth });
-
-      // Stamping is now the caller's job — ModelOps receives pre-stamped data.
-      // This test verifies ModelOps still accepts and passes through auth without error.
-      const result = await access.create('sales.Order', { name: 'Test' });
-      expect(result).toBeDefined();
-    });
-  });
-});