reqon-dsl 0.2.0

package/dist/stores/file.js

@@ -0,0 +1,173 @@
+import { writeFile } from 'node:fs/promises';
+import { writeFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { applyStoreFilter } from './types.js';
+import { ensureDirectory, readJsonFile, serialize, } from '../utils/file.js';
+const DEFAULT_OPTIONS = {
+    baseDir: '.reqon-data',
+    persist: 'immediate',
+    pretty: true,
+    debounceMs: 100,
+};
+/**
+ * File-based JSON store for local development
+ * Persists data to .reqon-data/{name}.json
+ */
+export class FileStore {
+    data = new Map();
+    filePath;
+    options;
+    dirty = false;
+    initialized;
+    debounceTimer = null;
+    pendingWrite = null;
+    constructor(name, options = {}) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.filePath = join(this.options.baseDir, `${name}.json`);
+        this.initialized = this.init();
+    }
+    async init() {
+        const dir = dirname(this.filePath);
+        await ensureDirectory(dir);
+        // Create .gitignore if it doesn't exist
+        const gitignorePath = join(dir, '.gitignore');
+        if (!existsSync(gitignorePath)) {
+            await writeFile(gitignorePath, '# Reqon local data\n*.json\n', 'utf-8');
+        }
+        await this.load();
+    }
+    async load() {
+        const parsed = await readJsonFile(this.filePath);
+        if (parsed) {
+            this.data = new Map(Object.entries(parsed));
+        }
+    }
+    async persist() {
+        if (this.options.persist === 'batch') {
+            this.dirty = true;
+            return;
+        }
+        if (this.options.persist === 'debounce') {
+            this.dirty = true;
+            this.scheduleDebouncedWrite();
+            return;
+        }
+        await this.writeToDisk();
+    }
+    scheduleDebouncedWrite() {
+        // Clear existing timer if any
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Schedule new write
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            if (this.dirty && !this.pendingWrite) {
+                this.pendingWrite = this.writeToDisk().finally(() => {
+                    this.pendingWrite = null;
+                });
+            }
+        }, this.options.debounceMs);
+    }
+    async writeToDisk() {
+        const obj = Object.fromEntries(this.data);
+        const content = serialize(obj, this.options.pretty);
+        await writeFile(this.filePath, content, 'utf-8');
+        this.dirty = false;
+    }
+    /** Synchronous write for flush/close operations */
+    writeToDiskSync() {
+        const obj = Object.fromEntries(this.data);
+        const content = serialize(obj, this.options.pretty);
+        writeFileSync(this.filePath, content, 'utf-8');
+        this.dirty = false;
+    }
+    async get(key) {
+        await this.initialized;
+        return this.data.get(key) ?? null;
+    }
+    async set(key, value) {
+        await this.initialized;
+        this.data.set(key, { ...value });
+        await this.persist();
+    }
+    async bulkSet(records) {
+        await this.initialized;
+        // Set all records in memory first (no disk I/O per record)
+        for (const { key, value } of records) {
+            this.data.set(key, { ...value });
+        }
+        // Single persist operation for all records
+        await this.persist();
+    }
+    async update(key, value) {
+        await this.initialized;
+        const existing = this.data.get(key);
+        if (existing) {
+            this.data.set(key, { ...existing, ...value });
+        }
+        else {
+            this.data.set(key, value);
+        }
+        await this.persist();
+    }
+    async delete(key) {
+        await this.initialized;
+        this.data.delete(key);
+        await this.persist();
+    }
+    async list(filter) {
+        await this.initialized;
+        return applyStoreFilter(Array.from(this.data.values()), filter);
+    }
+    async count(filter) {
+        await this.initialized;
+        // Apply only the where clause for counting (ignore limit/offset)
+        const filtered = applyStoreFilter(Array.from(this.data.values()), {
+            where: filter?.where,
+        });
+        return filtered.length;
+    }
+    async clear() {
+        await this.initialized;
+        this.data.clear();
+        await this.persist();
+    }
+    /**
+     * Flush pending changes to disk (needed in 'batch' or 'debounce' mode)
+     * Uses synchronous I/O to ensure data is written before process exits
+     */
+    flush() {
+        // Cancel any pending debounce timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.dirty) {
+            this.writeToDiskSync();
+        }
+    }
+    /**
+     * Close the store, ensuring all pending changes are written to disk.
+     * Should be called before the process exits to prevent data loss in batch mode.
+     */
+    close() {
+        this.flush();
+    }
+    /**
+     * Reload data from disk (useful if file was modified externally)
+     */
+    async reload() {
+        await this.load();
+    }
+    // For debugging
+    size() {
+        return this.data.size;
+    }
+    dump() {
+        return Array.from(this.data.values());
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+}

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

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

package/dist/stores/file.test.js

@@ -0,0 +1,165 @@
+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/index.d.ts

@@ -0,0 +1,6 @@
+export type { StoreAdapter, StoreFilter, StoreConfig } from './types.js';
+export { applyStoreFilter } from './types.js';
+export { MemoryStore } from './memory.js';
+export { FileStore, type FileStoreOptions } from './file.js';
+export { PostgRESTStore, PostgRESTError, type PostgRESTOptions } from './postgrest.js';
+export { createStore, resolveStoreType, type StoreType, type CreateStoreOptions } from './factory.js';

package/dist/stores/index.js

@@ -0,0 +1,5 @@
+export { applyStoreFilter } from './types.js';
+export { MemoryStore } from './memory.js';
+export { FileStore } from './file.js';
+export { PostgRESTStore, PostgRESTError } from './postgrest.js';
+export { createStore, resolveStoreType } from './factory.js';

package/dist/stores/memory.d.ts

@@ -0,0 +1,19 @@
+import type { StoreAdapter, StoreFilter } from './types.js';
+export declare class MemoryStore implements StoreAdapter {
+    private data;
+    private name;
+    constructor(name: string);
+    get(key: string): Promise<Record<string, unknown> | null>;
+    set(key: string, value: Record<string, unknown>): Promise<void>;
+    bulkSet(records: Array<{
+        key: string;
+        value: Record<string, unknown>;
+    }>): Promise<void>;
+    update(key: string, value: Partial<Record<string, unknown>>): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(filter?: StoreFilter): Promise<Record<string, unknown>[]>;
+    count(filter?: StoreFilter): Promise<number>;
+    clear(): Promise<void>;
+    size(): number;
+    dump(): Record<string, unknown>[];
+}

package/dist/stores/memory.js

@@ -0,0 +1,51 @@
+import { applyStoreFilter } from './types.js';
+export class MemoryStore {
+    data = new Map();
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    async get(key) {
+        return this.data.get(key) ?? null;
+    }
+    async set(key, value) {
+        this.data.set(key, { ...value });
+    }
+    async bulkSet(records) {
+        for (const { key, value } of records) {
+            this.data.set(key, { ...value });
+        }
+    }
+    async update(key, value) {
+        const existing = this.data.get(key);
+        if (existing) {
+            this.data.set(key, { ...existing, ...value });
+        }
+        else {
+            this.data.set(key, value);
+        }
+    }
+    async delete(key) {
+        this.data.delete(key);
+    }
+    async list(filter) {
+        return applyStoreFilter(Array.from(this.data.values()), filter);
+    }
+    async count(filter) {
+        // Apply only the where clause for counting (ignore limit/offset)
+        const filtered = applyStoreFilter(Array.from(this.data.values()), {
+            where: filter?.where,
+        });
+        return filtered.length;
+    }
+    async clear() {
+        this.data.clear();
+    }
+    // For debugging
+    size() {
+        return this.data.size;
+    }
+    dump() {
+        return Array.from(this.data.values());
+    }
+}

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

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

package/dist/stores/memory.test.js

@@ -0,0 +1,157 @@
+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/postgrest.d.ts

@@ -0,0 +1,55 @@
+import type { StoreAdapter, StoreFilter } from './types.js';
+export interface PostgRESTOptions {
+    /** Base URL for the PostgREST API (e.g., https://xxx.supabase.co/rest/v1) */
+    url: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Table name */
+    table: string;
+    /** Primary key column (default: 'id') */
+    primaryKey?: string;
+    /** Optional schema (for Supabase, typically 'public') */
+    schema?: string;
+}
+/**
+ * PostgREST-compatible store adapter.
+ * Works with Supabase, standalone PostgREST, or any PostgREST-compatible API.
+ *
+ * @example
+ * ```typescript
+ * const store = new PostgRESTStore({
+ *   url: 'https://xxx.supabase.co/rest/v1',
+ *   apiKey: process.env.SUPABASE_ANON_KEY,
+ *   table: 'users',
+ * });
+ * ```
+ */
+export declare class PostgRESTStore implements StoreAdapter {
+    private options;
+    private baseUrl;
+    private headers;
+    private primaryKey;
+    constructor(options: PostgRESTOptions);
+    get(key: string): Promise<Record<string, unknown> | null>;
+    set(key: string, value: Record<string, unknown>): Promise<void>;
+    update(key: string, value: Partial<Record<string, unknown>>): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(filter?: StoreFilter): Promise<Record<string, unknown>[]>;
+    clear(): Promise<void>;
+    /**
+     * Bulk insert records (more efficient than individual sets)
+     */
+    bulkInsert(records: Record<string, unknown>[]): Promise<void>;
+    /**
+     * Count records matching a filter
+     */
+    count(filter?: StoreFilter): Promise<number>;
+    private parseError;
+}
+/**
+ * Error class for PostgREST operations
+ */
+export declare class PostgRESTError extends Error {
+    statusCode: number;
+    constructor(message: string, statusCode: number);
+}