@rangka/core 0.0.1

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

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

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

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

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