reqon-dsl 0.2.0 → 0.4.0

package/dist/scheduler/cron-parser.test.js

@@ -1,188 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseCronExpression, getNextCronRun, intervalToMs, getNextRunTime, shouldRunNow, } from './cron-parser.js';
-describe('parseCronExpression', () => {
-    it('should parse simple cron expressions', () => {
-        const schedule = parseCronExpression('0 * * * *');
-        expect(schedule.minute).toEqual([0]);
-        expect(schedule.hour).toHaveLength(24); // All hours
-        expect(schedule.dayOfMonth).toHaveLength(31);
-        expect(schedule.month).toHaveLength(12);
-        expect(schedule.dayOfWeek).toHaveLength(7);
-    });
-    it('should parse specific values', () => {
-        const schedule = parseCronExpression('30 9 15 6 1');
-        expect(schedule.minute).toEqual([30]);
-        expect(schedule.hour).toEqual([9]);
-        expect(schedule.dayOfMonth).toEqual([15]);
-        expect(schedule.month).toEqual([6]);
-        expect(schedule.dayOfWeek).toEqual([1]);
-    });
-    it('should parse ranges', () => {
-        const schedule = parseCronExpression('0-5 9-17 * * 1-5');
-        expect(schedule.minute).toEqual([0, 1, 2, 3, 4, 5]);
-        expect(schedule.hour).toEqual([9, 10, 11, 12, 13, 14, 15, 16, 17]);
-        expect(schedule.dayOfWeek).toEqual([1, 2, 3, 4, 5]);
-    });
-    it('should parse step values', () => {
-        const schedule = parseCronExpression('*/15 */6 * * *');
-        expect(schedule.minute).toEqual([0, 15, 30, 45]);
-        expect(schedule.hour).toEqual([0, 6, 12, 18]);
-    });
-    it('should parse lists', () => {
-        const schedule = parseCronExpression('0,30 9,12,18 * * *');
-        expect(schedule.minute).toEqual([0, 30]);
-        expect(schedule.hour).toEqual([9, 12, 18]);
-    });
-    it('should parse combined expressions', () => {
-        const schedule = parseCronExpression('0 9-17/2 * * 1-5');
-        expect(schedule.minute).toEqual([0]);
-        expect(schedule.hour).toEqual([9, 11, 13, 15, 17]);
-        expect(schedule.dayOfWeek).toEqual([1, 2, 3, 4, 5]);
-    });
-    it('should throw on invalid cron expression', () => {
-        expect(() => parseCronExpression('0 * *')).toThrow('expected 5 fields');
-    });
-    it('should throw on out of range values', () => {
-        expect(() => parseCronExpression('60 * * * *')).toThrow('out of range');
-        expect(() => parseCronExpression('* 25 * * *')).toThrow('out of range');
-    });
-});
-describe('getNextCronRun', () => {
-    it('should calculate next run for every minute', () => {
-        const schedule = parseCronExpression('* * * * *');
-        const now = new Date('2025-01-20T10:30:00Z');
-        const next = getNextCronRun(schedule, now);
-        expect(next.getMinutes()).toBe(31);
-        expect(next.getHours()).toBe(10);
-    });
-    it('should calculate next run for specific time', () => {
-        const schedule = parseCronExpression('0 9 * * *');
-        const now = new Date('2025-01-20T10:30:00Z');
-        const next = getNextCronRun(schedule, now);
-        // Should be 9:00 the next day
-        expect(next.getMinutes()).toBe(0);
-        expect(next.getHours()).toBe(9);
-        expect(next.getDate()).toBe(21);
-    });
-    it('should handle hourly schedules', () => {
-        const schedule = parseCronExpression('0 * * * *');
-        const now = new Date('2025-01-20T10:30:00Z');
-        const next = getNextCronRun(schedule, now);
-        expect(next.getMinutes()).toBe(0);
-        expect(next.getHours()).toBe(11);
-    });
-    it('should handle day of week constraints', () => {
-        const schedule = parseCronExpression('0 9 * * 1'); // Monday only
-        const now = new Date('2025-01-20T10:30:00Z'); // This is a Monday
-        const next = getNextCronRun(schedule, now);
-        // Should be next Monday at 9:00
-        expect(next.getDay()).toBe(1); // Monday
-        expect(next.getHours()).toBe(9);
-        expect(next.getMinutes()).toBe(0);
-    });
-});
-describe('intervalToMs', () => {
-    it('should convert seconds to ms', () => {
-        const interval = { value: 30, unit: 'seconds' };
-        expect(intervalToMs(interval)).toBe(30_000);
-    });
-    it('should convert minutes to ms', () => {
-        const interval = { value: 5, unit: 'minutes' };
-        expect(intervalToMs(interval)).toBe(5 * 60 * 1000);
-    });
-    it('should convert hours to ms', () => {
-        const interval = { value: 6, unit: 'hours' };
-        expect(intervalToMs(interval)).toBe(6 * 60 * 60 * 1000);
-    });
-    it('should convert days to ms', () => {
-        const interval = { value: 1, unit: 'days' };
-        expect(intervalToMs(interval)).toBe(24 * 60 * 60 * 1000);
-    });
-    it('should convert weeks to ms', () => {
-        const interval = { value: 1, unit: 'weeks' };
-        expect(intervalToMs(interval)).toBe(7 * 24 * 60 * 60 * 1000);
-    });
-});
-describe('getNextRunTime', () => {
-    it('should calculate next run for interval schedule', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'interval',
-            interval: { value: 6, unit: 'hours' },
-        };
-        const now = new Date('2025-01-20T10:00:00Z');
-        const next = getNextRunTime(schedule, now);
-        expect(next).not.toBeNull();
-        expect(next.getTime()).toBe(now.getTime() + 6 * 60 * 60 * 1000);
-    });
-    it('should calculate next run for cron schedule', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'cron',
-            cronExpression: '0 */6 * * *',
-        };
-        const now = new Date('2025-01-20T10:30:00Z');
-        const next = getNextRunTime(schedule, now);
-        expect(next).not.toBeNull();
-        expect(next.getMinutes()).toBe(0);
-        expect(next.getHours()).toBe(12); // Next 6-hour mark
-    });
-    it('should calculate next run for one-time schedule', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'once',
-            runAt: '2025-01-25T15:00:00Z',
-        };
-        const now = new Date('2025-01-20T10:00:00Z');
-        const next = getNextRunTime(schedule, now);
-        expect(next).not.toBeNull();
-        expect(next.toISOString()).toBe('2025-01-25T15:00:00.000Z');
-    });
-    it('should return null for past one-time schedule', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'once',
-            runAt: '2025-01-15T15:00:00Z',
-        };
-        const now = new Date('2025-01-20T10:00:00Z');
-        const next = getNextRunTime(schedule, now);
-        expect(next).toBeNull();
-    });
-});
-describe('shouldRunNow', () => {
-    it('should return true for interval schedule that is due', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'interval',
-            interval: { value: 1, unit: 'hours' },
-        };
-        const lastRun = new Date(Date.now() - 61 * 60 * 1000); // 61 minutes ago
-        expect(shouldRunNow(schedule, lastRun)).toBe(true);
-    });
-    it('should return false for interval schedule not yet due', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'interval',
-            interval: { value: 1, unit: 'hours' },
-        };
-        const lastRun = new Date(Date.now() - 30 * 60 * 1000); // 30 minutes ago
-        expect(shouldRunNow(schedule, lastRun)).toBe(false);
-    });
-    it('should return true for first run of interval schedule', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'interval',
-            interval: { value: 1, unit: 'hours' },
-        };
-        expect(shouldRunNow(schedule, undefined)).toBe(true);
-    });
-    it('should return false for one-time schedule that already ran', () => {
-        const schedule = {
-            type: 'ScheduleDefinition',
-            scheduleType: 'once',
-            runAt: '2025-01-15T15:00:00Z',
-        };
-        const lastRun = new Date('2025-01-15T15:00:00Z');
-        expect(shouldRunNow(schedule, lastRun)).toBe(false);
-    });
-});

package/dist/stores/file.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/stores/file.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { existsSync, rmSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { FileStore } from './file.js';
-describe('FileStore', () => {
-    const TEST_DIR = '.reqon-test-stores';
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    afterEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    it('should create directory and file on first write', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        expect(existsSync(join(TEST_DIR, 'test-store.json'))).toBe(true);
-    });
-    it('should create .gitignore in data directory', () => {
-        new FileStore('test-store', { baseDir: TEST_DIR });
-        const gitignorePath = join(TEST_DIR, '.gitignore');
-        expect(existsSync(gitignorePath)).toBe(true);
-        const content = readFileSync(gitignorePath, 'utf-8');
-        expect(content).toContain('*.json');
-    });
-    it('should get a record by key', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        const record = await store.get('1');
-        expect(record).toEqual({ id: '1', name: 'Alice' });
-    });
-    it('should return null for non-existent key', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        const record = await store.get('nonexistent');
-        expect(record).toBeNull();
-    });
-    it('should update existing record', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice', age: 30 });
-        await store.update('1', { age: 31 });
-        const record = await store.get('1');
-        expect(record).toEqual({ id: '1', name: 'Alice', age: 31 });
-    });
-    it('should create record on update if not exists', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.update('1', { name: 'Alice' });
-        const record = await store.get('1');
-        expect(record).toEqual({ name: 'Alice' });
-    });
-    it('should delete a record', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        await store.delete('1');
-        const record = await store.get('1');
-        expect(record).toBeNull();
-    });
-    it('should list all records', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        await store.set('2', { id: '2', name: 'Bob' });
-        const records = await store.list();
-        expect(records).toHaveLength(2);
-    });
-    it('should filter records with where clause', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice', active: true });
-        await store.set('2', { id: '2', name: 'Bob', active: false });
-        await store.set('3', { id: '3', name: 'Charlie', active: true });
-        const records = await store.list({ where: { active: true } });
-        expect(records).toHaveLength(2);
-        expect(records.map(r => r.name)).toContain('Alice');
-        expect(records.map(r => r.name)).toContain('Charlie');
-    });
-    it('should support limit and offset', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        await store.set('2', { id: '2', name: 'Bob' });
-        await store.set('3', { id: '3', name: 'Charlie' });
-        const records = await store.list({ offset: 1, limit: 1 });
-        expect(records).toHaveLength(1);
-    });
-    it('should clear all records', async () => {
-        const store = new FileStore('test-store', { baseDir: TEST_DIR });
-        await store.set('1', { id: '1', name: 'Alice' });
-        await store.set('2', { id: '2', name: 'Bob' });
-        await store.clear();
-        const records = await store.list();
-        expect(records).toHaveLength(0);
-    });
-    describe('batch mode', () => {
-        it('should not write to disk until flush in batch mode', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR, persist: 'batch' });
-            const filePath = store.getFilePath();
-            await store.set('1', { id: '1', name: 'Alice' });
-            // File exists but should be empty or not contain data yet
-            const contentBefore = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '{}';
-            const parsedBefore = JSON.parse(contentBefore);
-            expect(Object.keys(parsedBefore)).toHaveLength(0);
-            // After flush, data should be persisted
-            store.flush();
-            const contentAfter = readFileSync(filePath, 'utf-8');
-            const parsedAfter = JSON.parse(contentAfter);
-            expect(parsedAfter['1']).toEqual({ id: '1', name: 'Alice' });
-        });
-    });
-    describe('persistence', () => {
-        it('should persist data across store instances', async () => {
-            const store1 = new FileStore('test-store', { baseDir: TEST_DIR });
-            await store1.set('1', { id: '1', name: 'Alice' });
-            const store2 = new FileStore('test-store', { baseDir: TEST_DIR });
-            const record = await store2.get('1');
-            expect(record).toEqual({ id: '1', name: 'Alice' });
-        });
-        it('should reload data from disk', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR });
-            await store.set('1', { id: '1', name: 'Alice' });
-            // Manually modify the file
-            const filePath = store.getFilePath();
-            const content = JSON.parse(readFileSync(filePath, 'utf-8'));
-            content['1'].name = 'Modified';
-            require('fs').writeFileSync(filePath, JSON.stringify(content));
-            // Reload and check
-            store.reload();
-            const record = await store.get('1');
-            expect(record?.name).toBe('Modified');
-        });
-    });
-    describe('pretty printing', () => {
-        it('should pretty-print JSON by default', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR });
-            await store.set('1', { id: '1', name: 'Alice' });
-            const content = readFileSync(store.getFilePath(), 'utf-8');
-            expect(content).toContain('\n'); // Pretty printed has newlines
-        });
-        it('should compact JSON when pretty is false', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR, pretty: false });
-            await store.set('1', { id: '1', name: 'Alice' });
-            const content = readFileSync(store.getFilePath(), 'utf-8');
-            expect(content).not.toContain('\n'); // Compact has no newlines
-        });
-    });
-    describe('utilities', () => {
-        it('should report size correctly', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR });
-            expect(store.size()).toBe(0);
-            await store.set('1', { id: '1' });
-            await store.set('2', { id: '2' });
-            expect(store.size()).toBe(2);
-        });
-        it('should dump all records', async () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR });
-            await store.set('1', { id: '1', name: 'Alice' });
-            await store.set('2', { id: '2', name: 'Bob' });
-            const dump = store.dump();
-            expect(dump).toHaveLength(2);
-        });
-        it('should return file path', () => {
-            const store = new FileStore('test-store', { baseDir: TEST_DIR });
-            expect(store.getFilePath()).toBe(join(TEST_DIR, 'test-store.json'));
-        });
-    });
-});

package/dist/stores/memory.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/stores/memory.test.js

@@ -1,157 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { MemoryStore } from './memory.js';
-describe('MemoryStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new MemoryStore('test');
-    });
-    describe('set and get', () => {
-        it('stores and retrieves a value', async () => {
-            await store.set('key1', { id: '1', name: 'Test' });
-            const result = await store.get('key1');
-            expect(result).toEqual({ id: '1', name: 'Test' });
-        });
-        it('returns null for non-existent key', async () => {
-            const result = await store.get('non-existent');
-            expect(result).toBeNull();
-        });
-        it('stores a copy of the value (not reference)', async () => {
-            const original = { id: '1', name: 'Test' };
-            await store.set('key1', original);
-            original.name = 'Modified';
-            const result = await store.get('key1');
-            expect(result?.name).toBe('Test');
-        });
-        it('overwrites existing value', async () => {
-            await store.set('key1', { id: '1', name: 'First' });
-            await store.set('key1', { id: '1', name: 'Second' });
-            const result = await store.get('key1');
-            expect(result?.name).toBe('Second');
-        });
-    });
-    describe('update', () => {
-        it('merges partial values with existing', async () => {
-            await store.set('key1', { id: '1', name: 'Test', status: 'active' });
-            await store.update('key1', { status: 'inactive' });
-            const result = await store.get('key1');
-            expect(result).toEqual({ id: '1', name: 'Test', status: 'inactive' });
-        });
-        it('creates new record if key does not exist', async () => {
-            await store.update('new-key', { id: '1', name: 'New' });
-            const result = await store.get('new-key');
-            expect(result).toEqual({ id: '1', name: 'New' });
-        });
-        it('preserves unmodified fields', async () => {
-            await store.set('key1', { a: 1, b: 2, c: 3 });
-            await store.update('key1', { b: 20 });
-            const result = await store.get('key1');
-            expect(result).toEqual({ a: 1, b: 20, c: 3 });
-        });
-    });
-    describe('delete', () => {
-        it('removes a record', async () => {
-            await store.set('key1', { id: '1' });
-            await store.delete('key1');
-            const result = await store.get('key1');
-            expect(result).toBeNull();
-        });
-        it('handles deleting non-existent key', async () => {
-            // Should not throw
-            await expect(store.delete('non-existent')).resolves.not.toThrow();
-        });
-    });
-    describe('list', () => {
-        beforeEach(async () => {
-            await store.set('1', { id: '1', name: 'Alice', age: 30, status: 'active' });
-            await store.set('2', { id: '2', name: 'Bob', age: 25, status: 'inactive' });
-            await store.set('3', { id: '3', name: 'Charlie', age: 35, status: 'active' });
-            await store.set('4', { id: '4', name: 'Diana', age: 28, status: 'active' });
-            await store.set('5', { id: '5', name: 'Eve', age: 32, status: 'inactive' });
-        });
-        it('returns all records when no filter', async () => {
-            const results = await store.list();
-            expect(results).toHaveLength(5);
-        });
-        it('filters by where clause', async () => {
-            const results = await store.list({ where: { status: 'active' } });
-            expect(results).toHaveLength(3);
-            expect(results.every((r) => r.status === 'active')).toBe(true);
-        });
-        it('filters by multiple where conditions', async () => {
-            const results = await store.list({
-                where: { status: 'active', age: 30 },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('Alice');
-        });
-        it('applies limit', async () => {
-            const results = await store.list({ limit: 3 });
-            expect(results).toHaveLength(3);
-        });
-        it('applies offset', async () => {
-            const allResults = await store.list();
-            const offsetResults = await store.list({ offset: 2 });
-            expect(offsetResults).toHaveLength(3);
-            expect(offsetResults[0]).toEqual(allResults[2]);
-        });
-        it('applies limit and offset together', async () => {
-            const allResults = await store.list();
-            const results = await store.list({ offset: 1, limit: 2 });
-            expect(results).toHaveLength(2);
-            expect(results[0]).toEqual(allResults[1]);
-            expect(results[1]).toEqual(allResults[2]);
-        });
-        it('combines where, limit, and offset', async () => {
-            const results = await store.list({
-                where: { status: 'active' },
-                offset: 1,
-                limit: 1,
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].status).toBe('active');
-        });
-        it('returns empty array when where matches nothing', async () => {
-            const results = await store.list({ where: { status: 'unknown' } });
-            expect(results).toEqual([]);
-        });
-    });
-    describe('clear', () => {
-        it('removes all records', async () => {
-            await store.set('1', { id: '1' });
-            await store.set('2', { id: '2' });
-            await store.set('3', { id: '3' });
-            await store.clear();
-            const results = await store.list();
-            expect(results).toHaveLength(0);
-        });
-    });
-    describe('size', () => {
-        it('returns 0 for empty store', () => {
-            expect(store.size()).toBe(0);
-        });
-        it('returns correct count', async () => {
-            await store.set('1', { id: '1' });
-            await store.set('2', { id: '2' });
-            expect(store.size()).toBe(2);
-        });
-        it('updates after delete', async () => {
-            await store.set('1', { id: '1' });
-            await store.set('2', { id: '2' });
-            await store.delete('1');
-            expect(store.size()).toBe(1);
-        });
-    });
-    describe('dump', () => {
-        it('returns all values as array', async () => {
-            await store.set('1', { id: '1', name: 'First' });
-            await store.set('2', { id: '2', name: 'Second' });
-            const dump = store.dump();
-            expect(dump).toHaveLength(2);
-            expect(dump).toContainEqual({ id: '1', name: 'First' });
-            expect(dump).toContainEqual({ id: '2', name: 'Second' });
-        });
-        it('returns empty array for empty store', () => {
-            expect(store.dump()).toEqual([]);
-        });
-    });
-});

package/dist/stores/stores.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/stores/stores.test.js

@@ -1,158 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rmSync, existsSync } from 'node:fs';
-import { FileStore } from './file.js';
-import { createStore, resolveStoreType } from './factory.js';
-const TEST_DIR = '.reqon-test-data';
-describe('FileStore', () => {
-    let store;
-    beforeEach(() => {
-        // Clean up test directory
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        store = new FileStore('test-store', { baseDir: TEST_DIR });
-    });
-    afterEach(() => {
-        // Clean up after tests
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    it('creates data directory and .gitignore', () => {
-        expect(existsSync(TEST_DIR)).toBe(true);
-        expect(existsSync(`${TEST_DIR}/.gitignore`)).toBe(true);
-    });
-    it('stores and retrieves data', async () => {
-        await store.set('item-1', { id: '1', name: 'Test Item' });
-        const retrieved = await store.get('item-1');
-        expect(retrieved).toEqual({ id: '1', name: 'Test Item' });
-    });
-    it('persists data to disk', async () => {
-        await store.set('item-1', { id: '1', name: 'Persisted' });
-        // Create new store instance pointing to same file
-        const newStore = new FileStore('test-store', { baseDir: TEST_DIR });
-        const retrieved = await newStore.get('item-1');
-        expect(retrieved).toEqual({ id: '1', name: 'Persisted' });
-    });
-    it('returns null for missing keys', async () => {
-        const result = await store.get('nonexistent');
-        expect(result).toBeNull();
-    });
-    it('updates existing records', async () => {
-        await store.set('item-1', { id: '1', name: 'Original', count: 0 });
-        await store.update('item-1', { count: 5 });
-        const retrieved = await store.get('item-1');
-        expect(retrieved).toEqual({ id: '1', name: 'Original', count: 5 });
-    });
-    it('deletes records', async () => {
-        await store.set('item-1', { id: '1' });
-        await store.delete('item-1');
-        const result = await store.get('item-1');
-        expect(result).toBeNull();
-    });
-    it('lists all records', async () => {
-        await store.set('a', { id: 'a', type: 'x' });
-        await store.set('b', { id: 'b', type: 'y' });
-        await store.set('c', { id: 'c', type: 'x' });
-        const all = await store.list();
-        expect(all).toHaveLength(3);
-    });
-    it('filters records with where clause', async () => {
-        await store.set('a', { id: 'a', type: 'x' });
-        await store.set('b', { id: 'b', type: 'y' });
-        await store.set('c', { id: 'c', type: 'x' });
-        const filtered = await store.list({ where: { type: 'x' } });
-        expect(filtered).toHaveLength(2);
-        expect(filtered.every((r) => r.type === 'x')).toBe(true);
-    });
-    it('clears all records', async () => {
-        await store.set('a', { id: 'a' });
-        await store.set('b', { id: 'b' });
-        await store.clear();
-        const all = await store.list();
-        expect(all).toHaveLength(0);
-    });
-    it('supports batch mode with flush', async () => {
-        const batchStore = new FileStore('batch-test', {
-            baseDir: TEST_DIR,
-            persist: 'batch',
-        });
-        await batchStore.set('item-1', { id: '1' });
-        await batchStore.set('item-2', { id: '2' });
-        // Before flush, new instance won't see changes
-        const beforeFlush = new FileStore('batch-test', { baseDir: TEST_DIR });
-        expect(await beforeFlush.get('item-1')).toBeNull();
-        // After flush, changes are persisted
-        batchStore.flush();
-        const afterFlush = new FileStore('batch-test', { baseDir: TEST_DIR });
-        expect(await afterFlush.get('item-1')).toEqual({ id: '1' });
-    });
-});
-describe('createStore factory', () => {
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    afterEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    it('creates memory store', async () => {
-        const store = createStore({ type: 'memory', name: 'test' });
-        await store.set('key', { value: 1 });
-        expect(await store.get('key')).toEqual({ value: 1 });
-    });
-    it('creates file store', async () => {
-        const store = createStore({
-            type: 'file',
-            name: 'test',
-            baseDir: TEST_DIR,
-        });
-        await store.set('key', { value: 1 });
-        // Verify persistence
-        const newStore = createStore({
-            type: 'file',
-            name: 'test',
-            baseDir: TEST_DIR,
-        });
-        expect(await newStore.get('key')).toEqual({ value: 1 });
-    });
-    it('falls back to file for sql in dev mode', async () => {
-        const store = createStore({
-            type: 'sql',
-            name: 'test',
-            baseDir: TEST_DIR,
-        });
-        await store.set('key', { value: 1 });
-        expect(await store.get('key')).toEqual({ value: 1 });
-    });
-    it('falls back to file for nosql in dev mode', async () => {
-        const store = createStore({
-            type: 'nosql',
-            name: 'test',
-            baseDir: TEST_DIR,
-        });
-        await store.set('key', { value: 1 });
-        expect(await store.get('key')).toEqual({ value: 1 });
-    });
-});
-describe('resolveStoreType', () => {
-    it('keeps memory as memory', () => {
-        expect(resolveStoreType('memory', true)).toBe('memory');
-        expect(resolveStoreType('memory', false)).toBe('memory');
-    });
-    it('maps sql to file in dev mode', () => {
-        expect(resolveStoreType('sql', true)).toBe('file');
-    });
-    it('maps nosql to file in dev mode', () => {
-        expect(resolveStoreType('nosql', true)).toBe('file');
-    });
-    it('keeps sql as sql in production mode', () => {
-        expect(resolveStoreType('sql', false)).toBe('sql');
-    });
-    it('keeps nosql as nosql in production mode', () => {
-        expect(resolveStoreType('nosql', false)).toBe('nosql');
-    });
-});