@rangka/core 0.0.1

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

@@ -0,0 +1,393 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resolveIncludes } from '../include-resolver.js';
+import type { SchemaRegistry } from '../../schema/registry.js';
+import type { ModelRelationship } from '../../schema/types.js';
+import type { ParsedInclude } from '../query-parser.js';
+
+// --- Test helpers ---
+
+function makeRegistry(relationships: ModelRelationship[]): SchemaRegistry {
+  return {
+    getRelationshipsForModel: (model: string) => relationships.filter((r) => r.from === model),
+    getModel: (qn: string) => ({ qualifiedName: qn }),
+  } as unknown as SchemaRegistry;
+}
+
+/**
+ * Creates a mock Kysely-like DB that stores tables in memory.
+ * Supports selectFrom with where('id', 'in', [...]) and where(field, 'in', [...]).
+ * Also supports innerJoin for manyToMany queries.
+ */
+function makeMockDb(tables: Record<string, any[]>) {
+  const db: any = {
+    selectFrom: vi.fn((table: string) => {
+      const q: any = {
+        _table: table,
+        _wheres: [] as any[],
+        _joins: [] as any[],
+        _selectAll: false,
+        _selects: [] as string[],
+      };
+      q.selectAll = vi.fn(() => {
+        q._selectAll = true;
+        return q;
+      });
+      q.select = vi.fn((fields: string[]) => {
+        q._selects.push(...fields);
+        return q;
+      });
+      q.where = vi.fn((field: string, op: string, value: any) => {
+        q._wheres.push({ field, op, value });
+        return q;
+      });
+      q.innerJoin = vi.fn((junctionTable: string, joinCol1: string, joinCol2: string) => {
+        q._joins.push({ junctionTable, joinCol1, joinCol2 });
+        return q;
+      });
+      q.execute = vi.fn(async () => {
+        let data = tables[q._table] ?? [];
+
+        // Handle manyToMany join
+        if (q._joins.length > 0) {
+          const join = q._joins[0];
+          const junctionData = tables[join.junctionTable] ?? [];
+          // join.joinCol1 = "junction.target_fk", join.joinCol2 = "target.id"
+          const targetFk = join.joinCol1.split('.')[1];
+          const sourceFk = q._wheres.find((w: any) => w.op === 'in')?.field?.split('.')[1];
+          const sourceIds = q._wheres.find((w: any) => w.op === 'in')?.value ?? [];
+
+          const results: any[] = [];
+          for (const jRow of junctionData) {
+            if (sourceIds.includes(jRow[sourceFk!])) {
+              const target = data.find((t: any) => t.id === jRow[targetFk]);
+              if (target) {
+                results.push({ ...target, _source_fk: jRow[sourceFk!] });
+              }
+            }
+          }
+          return results;
+        }
+
+        // Handle IN queries
+        for (const w of q._wheres) {
+          if (w.op === 'in') {
+            const field = w.field;
+            data = data.filter((r: any) => w.value.includes(r[field]));
+          }
+        }
+        return data;
+      });
+      return q;
+    }),
+  };
+  return db;
+}
+
+function makeRequest(scopeFilters: any[] = []): any {
+  return {
+    _scopeFilters: scopeFilters,
+  };
+}
+
+// --- Tests ---
+
+describe('resolveIncludes', () => {
+  describe('link (belongs-to)', () => {
+    const relationships: ModelRelationship[] = [
+      { type: 'link', from: 'sales.invoice', field: 'customer', to: 'sales.customer' },
+    ];
+
+    it('resolves single FK to full object', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__customer: [
+          { id: 'C-001', name: 'Acme Corp' },
+          { id: 'C-002', name: 'Globex' },
+        ],
+      });
+      const records = [
+        { id: 'inv-001', customer: 'C-001', total: 100 },
+        { id: 'inv-002', customer: 'C-002', total: 200 },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'customer' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].customer).toEqual({ id: 'C-001', name: 'Acme Corp' });
+      expect(records[1].customer).toEqual({ id: 'C-002', name: 'Globex' });
+    });
+
+    it('returns null for orphaned FK', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__customer: [{ id: 'C-001', name: 'Acme Corp' }],
+      });
+      const records = [{ id: 'inv-001', customer: 'C-999', total: 100 }];
+      const includes: ParsedInclude[] = [{ relation: 'customer' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].customer).toBeNull();
+    });
+
+    it('deduplicates IDs in batch query', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__customer: [{ id: 'C-001', name: 'Acme Corp' }],
+      });
+      const records = [
+        { id: 'inv-001', customer: 'C-001', total: 100 },
+        { id: 'inv-002', customer: 'C-001', total: 200 },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'customer' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].customer).toEqual({ id: 'C-001', name: 'Acme Corp' });
+      expect(records[1].customer).toEqual({ id: 'C-001', name: 'Acme Corp' });
+      // Only one selectFrom call (batched)
+      expect(db.selectFrom).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('hasMany (one-to-many)', () => {
+    const relationships: ModelRelationship[] = [
+      {
+        type: 'hasMany',
+        from: 'sales.invoice',
+        field: 'items',
+        to: 'sales.invoice_item',
+        foreignKey: 'invoice_id',
+      },
+    ];
+
+    it('returns array grouped by parent', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__invoice_item: [
+          { id: 'item-001', invoice_id: 'inv-001', qty: 10 },
+          { id: 'item-002', invoice_id: 'inv-001', qty: 5 },
+          { id: 'item-003', invoice_id: 'inv-002', qty: 3 },
+        ],
+      });
+      const records: any[] = [
+        { id: 'inv-001', total: 100 },
+        { id: 'inv-002', total: 200 },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'items' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].items).toHaveLength(2);
+      expect(records[0].items[0].id).toBe('item-001');
+      expect(records[1].items).toHaveLength(1);
+      expect(records[1].items[0].id).toBe('item-003');
+    });
+
+    it('returns empty array when no children exist', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({ sales__invoice_item: [] });
+      const records: any[] = [{ id: 'inv-001', total: 100 }];
+      const includes: ParsedInclude[] = [{ relation: 'items' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].items).toEqual([]);
+    });
+  });
+
+  describe('children (parent-child)', () => {
+    const relationships: ModelRelationship[] = [
+      {
+        type: 'children',
+        from: 'sales.order',
+        field: 'items',
+        to: 'sales.order_item',
+        foreignKey: 'order_id',
+      },
+    ];
+
+    it('behaves same as hasMany', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__order_item: [
+          { id: 'oi-001', order_id: 'ord-001', qty: 2 },
+          { id: 'oi-002', order_id: 'ord-001', qty: 7 },
+        ],
+      });
+      const records: any[] = [{ id: 'ord-001', total: 500 }];
+      const includes: ParsedInclude[] = [{ relation: 'items' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.order', makeRequest());
+
+      expect(records[0].items).toHaveLength(2);
+      expect(records[0].items[0].id).toBe('oi-001');
+    });
+  });
+
+  describe('manyToMany', () => {
+    const relationships: ModelRelationship[] = [
+      {
+        type: 'manyToMany',
+        from: 'sales.order',
+        field: 'tags',
+        to: 'core.tag',
+        through: 'sales.order_tag',
+      },
+    ];
+
+    it('resolves through junction table', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        core__tag: [
+          { id: 'tag-001', name: 'urgent' },
+          { id: 'tag-002', name: 'vip' },
+        ],
+        sales__order_tag: [
+          { order_id: 'ord-001', tag_id: 'tag-001' },
+          { order_id: 'ord-001', tag_id: 'tag-002' },
+          { order_id: 'ord-002', tag_id: 'tag-001' },
+        ],
+      });
+      const records: any[] = [
+        { id: 'ord-001', total: 100 },
+        { id: 'ord-002', total: 200 },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'tags' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.order', makeRequest());
+
+      expect(records[0].tags).toHaveLength(2);
+      expect(records[0].tags.map((t: any) => t.name)).toContain('urgent');
+      expect(records[0].tags.map((t: any) => t.name)).toContain('vip');
+      expect(records[1].tags).toHaveLength(1);
+      expect(records[1].tags[0].name).toBe('urgent');
+    });
+
+    it('returns empty array when no associations', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        core__tag: [{ id: 'tag-001', name: 'urgent' }],
+        sales__order_tag: [],
+      });
+      const records: any[] = [{ id: 'ord-001', total: 100 }];
+      const includes: ParsedInclude[] = [{ relation: 'tags' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.order', makeRequest());
+
+      expect(records[0].tags).toEqual([]);
+    });
+  });
+
+  describe('dynamicLink (polymorphic)', () => {
+    const relationships: ModelRelationship[] = [
+      {
+        type: 'dynamicLink',
+        from: 'core.comment',
+        field: 'reference',
+        to: '*',
+        modelField: 'reference_type',
+      },
+    ];
+
+    it('resolves grouped by discriminator', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__order: [{ id: 'ord-001', total: 500 }],
+        sales__invoice: [{ id: 'inv-001', total: 1000 }],
+      });
+      const records: any[] = [
+        { id: 'cmt-001', reference_type: 'sales.order', reference: 'ord-001' },
+        { id: 'cmt-002', reference_type: 'sales.invoice', reference: 'inv-001' },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'reference' }];
+
+      await resolveIncludes(records, includes, registry, db, 'core.comment', makeRequest());
+
+      expect(records[0].reference).toEqual({ id: 'ord-001', total: 500 });
+      expect(records[1].reference).toEqual({ id: 'inv-001', total: 1000 });
+    });
+
+    it('returns null when target not found', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({ sales__order: [] });
+      const records: any[] = [
+        { id: 'cmt-001', reference_type: 'sales.order', reference: 'ord-999' },
+      ];
+      const includes: ParsedInclude[] = [{ relation: 'reference' }];
+
+      await resolveIncludes(records, includes, registry, db, 'core.comment', makeRequest());
+
+      expect(records[0].reference).toBeNull();
+    });
+  });
+
+  describe('nested includes (depth 2)', () => {
+    const relationships: ModelRelationship[] = [
+      {
+        type: 'children',
+        from: 'sales.invoice',
+        field: 'items',
+        to: 'sales.invoice_item',
+        foreignKey: 'invoice_id',
+      },
+      {
+        type: 'link',
+        from: 'sales.invoice_item',
+        field: 'item_group',
+        to: 'core.item_group',
+      },
+    ];
+
+    it('resolves depth-2 nested includes', async () => {
+      const registry = makeRegistry(relationships);
+      const db = makeMockDb({
+        sales__invoice_item: [
+          { id: 'item-001', invoice_id: 'inv-001', item_group: 'grp-001', qty: 10 },
+          { id: 'item-002', invoice_id: 'inv-001', item_group: 'grp-002', qty: 5 },
+        ],
+        core__item_group: [
+          { id: 'grp-001', name: 'Finished Goods' },
+          { id: 'grp-002', name: 'Raw Materials' },
+        ],
+      });
+      const records: any[] = [{ id: 'inv-001', total: 1000 }];
+      const includes: ParsedInclude[] = [
+        { relation: 'items', nested: [{ relation: 'item_group' }] },
+      ];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].items[0].item_group).toEqual({ id: 'grp-001', name: 'Finished Goods' });
+      expect(records[0].items[1].item_group).toEqual({ id: 'grp-002', name: 'Raw Materials' });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty records array', async () => {
+      const registry = makeRegistry([
+        { type: 'link', from: 'sales.invoice', field: 'customer', to: 'sales.customer' },
+      ]);
+      const db = makeMockDb({});
+      const records: any[] = [];
+      const includes: ParsedInclude[] = [{ relation: 'customer' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records).toEqual([]);
+    });
+
+    it('handles null FK values in link fields', async () => {
+      const registry = makeRegistry([
+        { type: 'link', from: 'sales.invoice', field: 'customer', to: 'sales.customer' },
+      ]);
+      const db = makeMockDb({ sales__customer: [{ id: 'C-001', name: 'Acme' }] });
+      const records: any[] = [{ id: 'inv-001', customer: null, total: 100 }];
+      const includes: ParsedInclude[] = [{ relation: 'customer' }];
+
+      await resolveIncludes(records, includes, registry, db, 'sales.invoice', makeRequest());
+
+      expect(records[0].customer).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,100 @@
+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: 'test.item',
+    app: 'test',
+    module: 'test',
+    name: 'item',
+    auditLog: false,
+    traits: [],
+    fields: [{ name: 'id', config: { type: 'string' }, provenance: { source: 'base' } }],
+    indexes: [],
+  };
+}
+
+function makeRegistry(): SchemaRegistry {
+  const model = makeModel();
+  return {
+    getModelsByModule: () => new Map([['test', [model]]]),
+    getRelationshipsForModel: () => [],
+    getModel: (name: string) => (name === model.qualifiedName ? model : 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('Middleware hooks', () => {
+  it('registers onRequest, preHandler, and onSend hooks', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+
+    const res = await server.inject({ method: 'GET', url: '/api/test/item' });
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('onSend hook passes response through (field stripping placeholder)', async () => {
+    const server = await createServer();
+    generateRoutes(server, makeRegistry(), makeMockDb());
+
+    const res = await server.inject({ method: 'GET', url: '/api/test/item' });
+    const body = JSON.parse(res.body);
+    expect(body.data).toBeDefined();
+    expect(body.meta).toBeDefined();
+  });
+
+  it('hooks execute in order: onRequest → preHandler → handler → onSend', async () => {
+    const order: string[] = [];
+
+    const server = await createServer();
+
+    server.addHook('onRequest', async () => {
+      order.push('onRequest');
+    });
+    server.addHook('preHandler', async () => {
+      order.push('preHandler');
+    });
+
+    generateRoutes(server, makeRegistry(), makeMockDb());
+
+    server.addHook('onSend', async (_req, _rep, payload) => {
+      order.push('onSend');
+      return payload;
+    });
+
+    await server.inject({ method: 'GET', url: '/api/test/item' });
+
+    expect(order.indexOf('onRequest')).toBeLessThan(order.indexOf('preHandler'));
+    expect(order.indexOf('preHandler')).toBeLessThan(order.indexOf('onSend'));
+  });
+});

package/src/api/__tests__/openapi-schema.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import { fieldToJsonSchema, modelToSchemaComponent } from '../openapi-schema.js';
+import type { FieldConfig } from '@rangka/shared';
+import type { ResolvedModel } from '../../schema/types.js';
+
+describe('fieldToJsonSchema', () => {
+  it('maps string field', () => {
+    const result = fieldToJsonSchema({ type: 'string' } as FieldConfig);
+    expect(result).toEqual({ type: 'string' });
+  });
+
+  it('maps text field', () => {
+    const result = fieldToJsonSchema({ type: 'text' } as FieldConfig);
+    expect(result).toEqual({ type: 'string' });
+  });
+
+  it('maps int field', () => {
+    const result = fieldToJsonSchema({ type: 'int' } as FieldConfig);
+    expect(result).toEqual({ type: 'integer' });
+  });
+
+  it('maps decimal field', () => {
+    const result = fieldToJsonSchema({ type: 'decimal' } as FieldConfig);
+    expect(result).toEqual({ type: 'number' });
+  });
+
+  it('maps boolean field', () => {
+    const result = fieldToJsonSchema({ type: 'boolean' } as FieldConfig);
+    expect(result).toEqual({ type: 'boolean' });
+  });
+
+  it('maps date field with format', () => {
+    const result = fieldToJsonSchema({ type: 'date' } as FieldConfig);
+    expect(result).toEqual({ type: 'string', format: 'date' });
+  });
+
+  it('maps datetime field with format', () => {
+    const result = fieldToJsonSchema({ type: 'datetime' } as FieldConfig);
+    expect(result).toEqual({ type: 'string', format: 'date-time' });
+  });
+
+  it('maps enum field with values', () => {
+    const result = fieldToJsonSchema({
+      type: 'enum',
+      options: ['Draft', 'Submitted', 'Paid'],
+    } as FieldConfig);
+    expect(result).toEqual({ type: 'string', enum: ['Draft', 'Submitted', 'Paid'] });
+  });
+
+  it('maps json field', () => {
+    const result = fieldToJsonSchema({ type: 'json' } as FieldConfig);
+    expect(result).toEqual({ type: 'object' });
+  });
+
+  it('maps link field as string reference', () => {
+    const result = fieldToJsonSchema({ type: 'link', model: 'customer' } as FieldConfig);
+    expect(result).toEqual({ type: 'string', description: 'Reference to customer' });
+  });
+
+  it('maps money field as number', () => {
+    const result = fieldToJsonSchema({ type: 'money' } as FieldConfig);
+    expect(result).toEqual({ type: 'number' });
+  });
+
+  it('maps sequence field as string', () => {
+    const result = fieldToJsonSchema({ type: 'sequence' } as FieldConfig);
+    expect(result).toEqual({ type: 'string' });
+  });
+
+  it('returns null for hasMany', () => {
+    const result = fieldToJsonSchema({
+      type: 'hasMany',
+      model: 'item',
+      foreignKey: 'invoice_id',
+    } as FieldConfig);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for children', () => {
+    const result = fieldToJsonSchema({
+      type: 'children',
+      model: 'item',
+      foreignKey: 'invoice_id',
+    } as FieldConfig);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for manyToMany', () => {
+    const result = fieldToJsonSchema({
+      type: 'manyToMany',
+      model: 'tag',
+      through: 'invoice_tag',
+    } as FieldConfig);
+    expect(result).toBeNull();
+  });
+
+  it('returns null for tree', () => {
+    const result = fieldToJsonSchema({
+      type: 'tree',
+      strategy: 'materialized_path',
+    } as FieldConfig);
+    expect(result).toBeNull();
+  });
+});
+
+describe('modelToSchemaComponent', () => {
+  const baseModel: ResolvedModel = {
+    qualifiedName: 'sales.customer',
+    app: 'basic',
+    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: 'is_active',
+        config: { type: 'boolean', label: 'Active' },
+        provenance: { source: 'base' },
+      },
+    ],
+    indexes: [],
+  };
+
+  it('includes id property', () => {
+    const schema = modelToSchemaComponent(baseModel);
+    expect(schema.properties.id).toEqual({ type: 'string', description: 'Primary key' });
+  });
+
+  it('maps fields to properties', () => {
+    const schema = modelToSchemaComponent(baseModel);
+    expect(schema.properties.name).toEqual({ type: 'string', description: 'Customer Name' });
+    expect(schema.properties.email).toEqual({ type: 'string', description: 'Email' });
+    expect(schema.properties.is_active).toEqual({ type: 'boolean', description: 'Active' });
+  });
+
+  it('collects required fields', () => {
+    const schema = modelToSchemaComponent(baseModel);
+    expect(schema.required).toEqual(['name', 'email']);
+  });
+
+  it('omits required array when no fields are required', () => {
+    const model: ResolvedModel = {
+      ...baseModel,
+      fields: [{ name: 'notes', config: { type: 'text' }, provenance: { source: 'base' } }],
+    };
+    const schema = modelToSchemaComponent(model);
+    expect(schema.required).toBeUndefined();
+  });
+
+  it('uses label as description', () => {
+    const schema = modelToSchemaComponent(baseModel);
+    expect(schema.properties.name.description).toBe('Customer Name');
+  });
+
+  it('omits description when no label', () => {
+    const model: ResolvedModel = {
+      ...baseModel,
+      fields: [{ name: 'code', config: { type: 'string' }, provenance: { source: 'base' } }],
+    };
+    const schema = modelToSchemaComponent(model);
+    expect(schema.properties.code.description).toBeUndefined();
+  });
+
+  it('includes enum values', () => {
+    const model: ResolvedModel = {
+      ...baseModel,
+      fields: [
+        {
+          name: 'status',
+          config: { type: 'enum', options: ['Draft', 'Submitted', 'Paid'] },
+          provenance: { source: 'base' },
+        },
+      ],
+    };
+    const schema = modelToSchemaComponent(model);
+    expect(schema.properties.status.enum).toEqual(['Draft', 'Submitted', 'Paid']);
+  });
+
+  it('skips relationship fields that return null', () => {
+    const model: ResolvedModel = {
+      ...baseModel,
+      fields: [
+        {
+          name: 'name',
+          config: { type: 'string', required: true },
+          provenance: { source: 'base' },
+        },
+        {
+          name: 'items',
+          config: { type: 'hasMany', model: 'item', foreignKey: 'customer_id' },
+          provenance: { source: 'base' },
+        },
+      ],
+    };
+    const schema = modelToSchemaComponent(model);
+    expect(schema.properties.items).toBeUndefined();
+    expect(schema.properties.name).toBeDefined();
+  });
+});