@rangka/core 0.1.1 → 0.1.3

package/src/db/__tests__/field-mapper.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mapFieldsToColumns, modelToTableName } from '../field-mapper.js';
-import type { ResolvedModel, ResolvedField } from '../../schema/types.js';
-
-function makeModel(overrides: Partial<ResolvedModel> = {}): ResolvedModel {
-  return {
-    qualifiedName: 'sales.invoice',
-    app: 'sales',
-    module: 'sales',
-    name: 'invoice',
-    auditLog: true,
-    traits: [],
-    fields: [],
-    indexes: [],
-    ...overrides,
-  };
-}
-
-function makeField(name: string, config: any): ResolvedField {
-  return { name, config, provenance: { source: 'base' } };
-}
-
-describe('modelToTableName', () => {
-  it('converts qualified name to table name', () => {
-    expect(modelToTableName('sales.invoice')).toBe('sales__invoice');
-  });
-
-  it('handles single-segment names', () => {
-    expect(modelToTableName('core.user')).toBe('core__user');
-  });
-});
-
-describe('mapFieldsToColumns', () => {
-  it('always includes id UUID primary key', () => {
-    const model = makeModel();
-    const result = mapFieldsToColumns(model);
-    const idCol = result.columns.find((c) => c.name === 'id');
-    expect(idCol).toBeDefined();
-    expect(idCol!.type).toBe('UUID');
-    expect(idCol!.primaryKey).toBe(true);
-    expect(idCol!.defaultValue).toBe('gen_random_uuid()');
-  });
-
-  describe('primitive fields', () => {
-    it('maps string field to VARCHAR', () => {
-      const model = makeModel({
-        fields: [makeField('title', { type: 'string', maxLength: 200 })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'title');
-      expect(col).toBeDefined();
-      expect(col!.type).toBe('VARCHAR(200)');
-    });
-
-    it('maps string field with default maxLength', () => {
-      const model = makeModel({
-        fields: [makeField('title', { type: 'string' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'title');
-      expect(col!.type).toBe('VARCHAR(255)');
-    });
-
-    it('maps text field to TEXT', () => {
-      const model = makeModel({
-        fields: [makeField('description', { type: 'text' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'description');
-      expect(col!.type).toBe('TEXT');
-    });
-
-    it('maps int field to INTEGER', () => {
-      const model = makeModel({
-        fields: [makeField('quantity', { type: 'int' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'quantity');
-      expect(col!.type).toBe('INTEGER');
-    });
-
-    it('maps decimal field to DECIMAL with precision/scale', () => {
-      const model = makeModel({
-        fields: [makeField('rate', { type: 'decimal', precision: 10, scale: 2 })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'rate');
-      expect(col!.type).toBe('DECIMAL(10,2)');
-    });
-
-    it('maps decimal field with default precision/scale', () => {
-      const model = makeModel({
-        fields: [makeField('amount', { type: 'decimal' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'amount');
-      expect(col!.type).toBe('DECIMAL(18,6)');
-    });
-
-    it('maps boolean field to BOOLEAN', () => {
-      const model = makeModel({
-        fields: [makeField('is_active', { type: 'boolean' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'is_active');
-      expect(col!.type).toBe('BOOLEAN');
-    });
-
-    it('maps date field to DATE', () => {
-      const model = makeModel({
-        fields: [makeField('posting_date', { type: 'date' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'posting_date');
-      expect(col!.type).toBe('DATE');
-    });
-
-    it('maps datetime field to TIMESTAMPTZ', () => {
-      const model = makeModel({
-        fields: [makeField('created', { type: 'datetime' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'created');
-      expect(col!.type).toBe('TIMESTAMPTZ');
-    });
-
-    it('maps enum field to VARCHAR with CHECK constraint', () => {
-      const model = makeModel({
-        fields: [makeField('status', { type: 'enum', options: ['Draft', 'Submitted', 'Paid'] })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'status');
-      expect(col!.type).toBe('VARCHAR(255)');
-      expect(result.checkConstraints).toHaveLength(1);
-      expect(result.checkConstraints[0].expression).toContain("'Draft'");
-      expect(result.checkConstraints[0].expression).toContain("'Submitted'");
-      expect(result.checkConstraints[0].expression).toContain("'Paid'");
-    });
-
-    it('maps json field to JSONB', () => {
-      const model = makeModel({
-        fields: [makeField('metadata', { type: 'json' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'metadata');
-      expect(col!.type).toBe('JSONB');
-    });
-
-    it('maps code field to TEXT', () => {
-      const model = makeModel({
-        fields: [makeField('formula', { type: 'code', language: 'expression' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'formula');
-      expect(col!.type).toBe('TEXT');
-    });
-  });
-
-  describe('link fields', () => {
-    it('maps link field to UUID with FK', () => {
-      const model = makeModel({
-        fields: [makeField('customer', { type: 'link', model: 'sales.customer' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'customer');
-      expect(col!.type).toBe('UUID');
-      expect(result.foreignKeys).toHaveLength(1);
-      expect(result.foreignKeys[0].referencedTable).toBe('sales__customer');
-      expect(result.foreignKeys[0].referencedColumn).toBe('id');
-    });
-
-    it('maps required link field to NOT NULL', () => {
-      const model = makeModel({
-        fields: [
-          makeField('customer', {
-            type: 'link',
-            model: 'sales.customer',
-            required: true,
-            nullable: false,
-          }),
-        ],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'customer');
-      expect(col!.nullable).toBe(false);
-    });
-  });
-
-  describe('dynamic link fields', () => {
-    it('maps dynamicLink to discriminator + UUID columns', () => {
-      const model = makeModel({
-        fields: [makeField('source_document', { type: 'dynamicLink', modelField: 'source_type' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const typeCol = result.columns.find((c) => c.name === 'source_type');
-      const idCol = result.columns.find((c) => c.name === 'source_document');
-      expect(typeCol!.type).toBe('VARCHAR(255)');
-      expect(idCol!.type).toBe('UUID');
-      expect(result.foreignKeys).toHaveLength(0);
-    });
-  });
-
-  describe('money fields', () => {
-    it('maps money field to two DECIMAL columns', () => {
-      const model = makeModel({
-        fields: [makeField('total_amount', { type: 'money' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const valueCol = result.columns.find((c) => c.name === 'total_amount');
-      const baseCol = result.columns.find((c) => c.name === 'total_amount_base');
-      expect(valueCol!.type).toBe('DECIMAL(18,6)');
-      expect(baseCol!.type).toBe('DECIMAL(18,6)');
-    });
-  });
-
-  describe('tree fields', () => {
-    it('maps materialized_path tree to parent + path + depth', () => {
-      const model = makeModel({
-        fields: [makeField('parent', { type: 'tree', strategy: 'materialized_path' })],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'parent')).toBeDefined();
-      expect(result.columns.find((c) => c.name === 'path')).toBeDefined();
-      expect(result.columns.find((c) => c.name === 'depth')).toBeDefined();
-      expect(result.foreignKeys.find((fk) => fk.column === 'parent')!.referencedTable).toBe(
-        'sales__invoice',
-      );
-    });
-
-    it('maps nested_set tree to parent + lft + rgt', () => {
-      const model = makeModel({
-        fields: [makeField('parent', { type: 'tree', strategy: 'nested_set' })],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'parent')).toBeDefined();
-      expect(result.columns.find((c) => c.name === 'lft')).toBeDefined();
-      expect(result.columns.find((c) => c.name === 'rgt')).toBeDefined();
-    });
-
-    it('maps closure_table tree to parent + extra closure table', () => {
-      const model = makeModel({
-        fields: [makeField('parent', { type: 'tree', strategy: 'closure_table' })],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'parent')).toBeDefined();
-      expect(result.extraTables).toHaveLength(1);
-      expect(result.extraTables[0].name).toBe('sales__invoice_closure');
-      expect(result.extraTables[0].columns.map((c) => c.name)).toEqual([
-        'ancestor_id',
-        'descendant_id',
-        'depth',
-      ]);
-    });
-  });
-
-  describe('sequence fields', () => {
-    it('maps sequence field to VARCHAR', () => {
-      const model = makeModel({
-        fields: [makeField('invoice_number', { type: 'sequence', prefix: 'INV-', digits: 5 })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'invoice_number');
-      expect(col!.type).toBe('VARCHAR(255)');
-    });
-  });
-
-  describe('relationship fields (no columns)', () => {
-    it('hasMany produces no columns', () => {
-      const model = makeModel({
-        fields: [
-          makeField('items', {
-            type: 'hasMany',
-            model: 'sales.invoice_item',
-            foreignKey: 'invoice_id',
-          }),
-        ],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'items')).toBeUndefined();
-    });
-
-    it('children produces no columns', () => {
-      const model = makeModel({
-        fields: [
-          makeField('items', {
-            type: 'children',
-            model: 'sales.invoice_item',
-            foreignKey: 'parent',
-          }),
-        ],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'items')).toBeUndefined();
-    });
-
-    it('manyToMany produces no columns', () => {
-      const model = makeModel({
-        fields: [
-          makeField('tags', { type: 'manyToMany', model: 'core.tag', through: 'invoice_tag' }),
-        ],
-      });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'tags')).toBeUndefined();
-    });
-  });
-
-  describe('trait column injection', () => {
-    it('timestamped adds created_at/updated_at/created_by/updated_by', () => {
-      const model = makeModel({ traits: ['timestamped'] });
-      const result = mapFieldsToColumns(model);
-      expect(result.columns.find((c) => c.name === 'created_at')!.type).toBe('TIMESTAMPTZ');
-      expect(result.columns.find((c) => c.name === 'updated_at')!.type).toBe('TIMESTAMPTZ');
-      expect(result.columns.find((c) => c.name === 'created_by')!.type).toBe('UUID');
-      expect(result.columns.find((c) => c.name === 'updated_by')!.type).toBe('UUID');
-    });
-  });
-
-  describe('default values', () => {
-    it('maps boolean default', () => {
-      const model = makeModel({
-        fields: [makeField('is_active', { type: 'boolean', default: false })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'is_active');
-      expect(col!.defaultValue).toBe('FALSE');
-    });
-
-    it('maps string default', () => {
-      const model = makeModel({
-        fields: [makeField('status', { type: 'string', default: 'Draft' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'status');
-      expect(col!.defaultValue).toBe("'Draft'");
-    });
-
-    it('maps numeric default', () => {
-      const model = makeModel({
-        fields: [makeField('quantity', { type: 'int', default: 1 })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'quantity');
-      expect(col!.defaultValue).toBe('1');
-    });
-
-    it('no default when not specified', () => {
-      const model = makeModel({
-        fields: [makeField('title', { type: 'string' })],
-      });
-      const result = mapFieldsToColumns(model);
-      const col = result.columns.find((c) => c.name === 'title');
-      expect(col!.defaultValue).toBeUndefined();
-    });
-  });
-});

package/src/db/__tests__/introspect.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { introspect } from '../introspect.js';
-
-function createMockDb(responses: any[][]) {
-  let callCount = 0;
-  const mockExecutor = {
-    transformQuery: vi.fn().mockImplementation((node: any) => node),
-    compileQuery: vi.fn().mockImplementation(() => ({ sql: '', parameters: [] })),
-    executeQuery: vi.fn().mockImplementation(() => {
-      const rows = responses[callCount] ?? [];
-      callCount++;
-      return Promise.resolve({ rows });
-    }),
-  };
-
-  return {
-    getExecutor: () => mockExecutor,
-  } as any;
-}
-
-describe('introspect', () => {
-  it('returns empty state for database with no tables', async () => {
-    const mockDb = createMockDb([[]]);
-
-    const result = await introspect(mockDb);
-    expect(result.tables).toHaveLength(0);
-  });
-
-  it('returns table with columns when tables exist', async () => {
-    const tableRows = [{ table_name: 'sales__invoice' }];
-    const columnRows = [
-      {
-        column_name: 'id',
-        data_type: 'uuid',
-        is_nullable: 'NO',
-        column_default: 'gen_random_uuid()',
-        character_maximum_length: null,
-        numeric_precision: null,
-        numeric_scale: null,
-        udt_name: 'uuid',
-      },
-      {
-        column_name: 'title',
-        data_type: 'character varying',
-        is_nullable: 'YES',
-        column_default: null,
-        character_maximum_length: 255,
-        numeric_precision: null,
-        numeric_scale: null,
-        udt_name: 'varchar',
-      },
-    ];
-    const fkRows: any[] = [];
-    const indexRows: any[] = [];
-    const checkRows: any[] = [];
-
-    const mockDb = createMockDb([tableRows, columnRows, fkRows, indexRows, checkRows]);
-
-    const result = await introspect(mockDb);
-    expect(result.tables).toHaveLength(1);
-    expect(result.tables[0].name).toBe('sales__invoice');
-    expect(result.tables[0].columns).toHaveLength(2);
-    expect(result.tables[0].columns[0].name).toBe('id');
-    expect(result.tables[0].columns[0].type).toBe('UUID');
-    expect(result.tables[0].columns[0].nullable).toBe(false);
-    expect(result.tables[0].columns[1].name).toBe('title');
-    expect(result.tables[0].columns[1].type).toBe('VARCHAR(255)');
-    expect(result.tables[0].columns[1].nullable).toBe(true);
-  });
-});

package/src/db/__tests__/search-filter.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { applySearchFilter } from '../filter-applier.js';
-
-describe('applySearchFilter', () => {
-  function createMockQuery() {
-    const conditions: any[] = [];
-    const query = {
-      where: (arg: any) => {
-        conditions.push(arg);
-        return query;
-      },
-      getConditions: () => conditions,
-    };
-    return query;
-  }
-
-  it('returns query unchanged when term is empty', () => {
-    const query = createMockQuery();
-    const result = applySearchFilter(query, '', ['name', 'email']);
-    expect(result).toBe(query);
-    expect(query.getConditions()).toHaveLength(0);
-  });
-
-  it('returns query unchanged when fields array is empty', () => {
-    const query = createMockQuery();
-    const result = applySearchFilter(query, 'test', []);
-    expect(result).toBe(query);
-    expect(query.getConditions()).toHaveLength(0);
-  });
-
-  it('adds a where clause for non-empty term and fields', () => {
-    const query = createMockQuery();
-    const result = applySearchFilter(query, 'test', ['name', 'email']);
-    expect(result).toBe(query);
-    expect(query.getConditions()).toHaveLength(1);
-    expect(typeof query.getConditions()[0]).toBe('function');
-  });
-
-  it('escapes % and _ in search term', () => {
-    const query = createMockQuery();
-    const result = applySearchFilter(query, '100%_done', ['name']);
-    expect(result).toBe(query);
-    expect(query.getConditions()).toHaveLength(1);
-  });
-});

package/src/db/__tests__/sequence.test.ts

@@ -1,221 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { KyselyModelOps } from '../model-ops.js';
-import type { ResolvedModel } from '../../schema/types.js';
-import type { SchemaRegistry } from '../../schema/registry.js';
-
-function createMockDb() {
-  const returningFn = vi.fn();
-  const executeTakeFirstOrThrowFn = vi.fn();
-  const onConflictDoUpdateSetFn = vi.fn();
-  const onConflictColumnsFn = vi.fn();
-  const onConflictFn = vi.fn();
-  const valuesFn = vi.fn();
-  const returningAllFn = vi.fn();
-  const insertIntoFn = vi.fn();
-
-  executeTakeFirstOrThrowFn.mockResolvedValue({ next_val: 1 });
-  returningFn.mockReturnValue({ executeTakeFirstOrThrow: executeTakeFirstOrThrowFn });
-  onConflictDoUpdateSetFn.mockReturnValue({ returning: returningFn });
-  onConflictColumnsFn.mockReturnValue({ doUpdateSet: onConflictDoUpdateSetFn });
-  onConflictFn.mockImplementation((cb: any) => {
-    const oc = { columns: onConflictColumnsFn };
-    return cb(oc);
-  });
-  valuesFn.mockReturnValue({ onConflict: onConflictFn });
-
-  const insertReturningAllExecute = vi.fn().mockResolvedValue({ id: 'abc', name: 'INV-00001' });
-  returningAllFn.mockReturnValue({ executeTakeFirstOrThrow: insertReturningAllExecute });
-
-  insertIntoFn.mockImplementation((table: string) => {
-    if (table === 'naming_sequence') {
-      return { values: valuesFn };
-    }
-    return {
-      values: vi.fn().mockReturnValue({ returningAll: returningAllFn }),
-    };
-  });
-
-  return {
-    db: {
-      insertInto: insertIntoFn,
-      selectFrom: vi.fn(),
-      updateTable: vi.fn(),
-      deleteFrom: vi.fn(),
-    },
-    insertIntoFn,
-    executeTakeFirstOrThrowFn,
-    valuesFn,
-    insertReturningAllExecute,
-  };
-}
-
-function createModel(fields: ResolvedModel['fields']): ResolvedModel {
-  return {
-    qualifiedName: 'sales.invoice',
-    app: 'sales',
-    module: 'sales',
-    name: 'invoice',
-    auditLog: false,
-    traits: [],
-    fields,
-    indexes: [],
-  };
-}
-
-const mockRegistry = { getModel: vi.fn() } as unknown as SchemaRegistry;
-
-describe('KyselyModelOps sequence field', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('assigns sequence value on create when field is empty', async () => {
-    const { db, insertReturningAllExecute } = createMockDb();
-    insertReturningAllExecute.mockResolvedValue({ id: 'abc', invoice_number: 'INV-00001' });
-
-    const model = createModel([
-      {
-        name: 'invoice_number',
-        config: { type: 'sequence', prefix: 'INV-', digits: 5 },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = { customer: 'cust-1' };
-    await ops.create(data);
-
-    expect(data.invoice_number).toBe('INV-00001');
-  });
-
-  it('does not override sequence value if already provided', async () => {
-    const { db, insertIntoFn } = createMockDb();
-
-    const model = createModel([
-      {
-        name: 'invoice_number',
-        config: { type: 'sequence', prefix: 'INV-', digits: 5 },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = { invoice_number: 'CUSTOM-001', customer: 'cust-1' };
-    await ops.create(data);
-
-    expect(data.invoice_number).toBe('CUSTOM-001');
-    const namingCalls = insertIntoFn.mock.calls.filter((c: any) => c[0] === 'naming_sequence');
-    expect(namingCalls).toHaveLength(0);
-  });
-
-  it('formats sequence without prefix when prefix is omitted', async () => {
-    const { db, executeTakeFirstOrThrowFn } = createMockDb();
-    executeTakeFirstOrThrowFn.mockResolvedValue({ next_val: 42 });
-
-    const model = createModel([
-      {
-        name: 'code',
-        config: { type: 'sequence', digits: 4 },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = {};
-    await ops.create(data);
-
-    expect(data.code).toBe('0042');
-  });
-
-  it('formats sequence without padding when digits is omitted', async () => {
-    const { db, executeTakeFirstOrThrowFn } = createMockDb();
-    executeTakeFirstOrThrowFn.mockResolvedValue({ next_val: 7 });
-
-    const model = createModel([
-      {
-        name: 'ref',
-        config: { type: 'sequence', prefix: 'REF-' },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = {};
-    await ops.create(data);
-
-    expect(data.ref).toBe('REF-7');
-  });
-
-  it('handles multiple sequence fields on the same model', async () => {
-    const { db, executeTakeFirstOrThrowFn } = createMockDb();
-    let callCount = 0;
-    executeTakeFirstOrThrowFn.mockImplementation(() => {
-      callCount++;
-      return Promise.resolve({ next_val: callCount });
-    });
-
-    const model = createModel([
-      {
-        name: 'invoice_number',
-        config: { type: 'sequence', prefix: 'INV-', digits: 5 },
-        provenance: { source: 'base' },
-      },
-      {
-        name: 'receipt_number',
-        config: { type: 'sequence', prefix: 'REC-', digits: 3 },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = {};
-    await ops.create(data);
-
-    expect(data.invoice_number).toBe('INV-00001');
-    expect(data.receipt_number).toBe('REC-002');
-  });
-
-  it('skips sequence logic when model has no sequence fields', async () => {
-    const { db, insertIntoFn } = createMockDb();
-
-    const model = createModel([
-      {
-        name: 'title',
-        config: { type: 'string' },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-    const data: Record<string, unknown> = { title: 'Test' };
-    await ops.create(data);
-
-    const namingCalls = insertIntoFn.mock.calls.filter((c: any) => c[0] === 'naming_sequence');
-    expect(namingCalls).toHaveLength(0);
-  });
-
-  it('increments correctly for subsequent calls', async () => {
-    const { db, executeTakeFirstOrThrowFn } = createMockDb();
-    executeTakeFirstOrThrowFn
-      .mockResolvedValueOnce({ next_val: 1 })
-      .mockResolvedValueOnce({ next_val: 2 });
-
-    const model = createModel([
-      {
-        name: 'order_number',
-        config: { type: 'sequence', prefix: 'ORD-', digits: 6 },
-        provenance: { source: 'base' },
-      },
-    ]);
-
-    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
-
-    const data1: Record<string, unknown> = {};
-    await ops.create(data1);
-    expect(data1.order_number).toBe('ORD-000001');
-
-    const data2: Record<string, unknown> = {};
-    await ops.create(data2);
-    expect(data2.order_number).toBe('ORD-000002');
-  });
-});