reqon-dsl 0.2.0 → 0.4.0

package/dist/sync/sync.test.d.ts

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

package/dist/sync/sync.test.js

@@ -1,221 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { rmSync, existsSync } from 'node:fs';
-import { generateCheckpointKey, formatSinceDate, parseSinceDate, EPOCH, } from './state.js';
-import { FileSyncStore, MemorySyncStore } from './store.js';
-import { ReqonLexer } from '../lexer/index.js';
-import { ReqonParser } from '../parser/parser.js';
-const TEST_DIR = '.reqon-test-sync';
-describe('Sync State Utilities', () => {
-    describe('generateCheckpointKey', () => {
-        it('generates key from source and operationId', () => {
-            const key = generateCheckpointKey('Xero', 'getInvoices');
-            expect(key).toBe('Xero:getInvoices');
-        });
-        it('generates key from source and endpoint', () => {
-            const key = generateCheckpointKey('API', undefined, '/invoices');
-            expect(key).toBe('API:/invoices');
-        });
-        it('normalizes endpoints (removes trailing slashes)', () => {
-            const key = generateCheckpointKey('API', undefined, '/invoices/');
-            expect(key).toBe('API:/invoices');
-        });
-        it('falls back to source only', () => {
-            const key = generateCheckpointKey('API');
-            expect(key).toBe('API');
-        });
-    });
-    describe('formatSinceDate', () => {
-        const date = new Date('2024-01-15T10:30:00.000Z');
-        it('formats as ISO string', () => {
-            expect(formatSinceDate(date, 'iso')).toBe('2024-01-15T10:30:00.000Z');
-        });
-        it('formats as Unix timestamp (seconds)', () => {
-            expect(formatSinceDate(date, 'unix')).toBe('1705314600');
-        });
-        it('formats as Unix timestamp (milliseconds)', () => {
-            expect(formatSinceDate(date, 'unix-ms')).toBe('1705314600000');
-        });
-        it('formats as date only', () => {
-            expect(formatSinceDate(date, 'date-only')).toBe('2024-01-15');
-        });
-    });
-    describe('parseSinceDate', () => {
-        it('parses ISO string', () => {
-            const result = parseSinceDate('2024-01-15T10:30:00.000Z');
-            expect(result).toBeInstanceOf(Date);
-            expect(result?.toISOString()).toBe('2024-01-15T10:30:00.000Z');
-        });
-        it('parses Unix timestamp (seconds)', () => {
-            const result = parseSinceDate(1705314600);
-            expect(result).toBeInstanceOf(Date);
-            expect(result?.getTime()).toBe(1705314600000);
-        });
-        it('parses Unix timestamp (milliseconds)', () => {
-            const result = parseSinceDate(1705314600000);
-            expect(result).toBeInstanceOf(Date);
-            expect(result?.getTime()).toBe(1705314600000);
-        });
-        it('returns null for invalid input', () => {
-            expect(parseSinceDate('not a date')).toBeNull();
-            expect(parseSinceDate(null)).toBeNull();
-            expect(parseSinceDate(undefined)).toBeNull();
-        });
-        it('passes through Date objects', () => {
-            const date = new Date();
-            expect(parseSinceDate(date)).toBe(date);
-        });
-    });
-});
-describe('MemorySyncStore', () => {
-    let store;
-    beforeEach(() => {
-        store = new MemorySyncStore();
-    });
-    it('returns EPOCH for unknown keys', async () => {
-        const lastSync = await store.getLastSync('unknown');
-        expect(lastSync.getTime()).toBe(EPOCH.getTime());
-    });
-    it('records and retrieves sync checkpoints', async () => {
-        const syncedAt = new Date();
-        await store.recordSync({
-            key: 'Xero:getInvoices',
-            syncedAt,
-            recordCount: 100,
-        });
-        const lastSync = await store.getLastSync('Xero:getInvoices');
-        expect(lastSync.getTime()).toBe(syncedAt.getTime());
-        const checkpoint = await store.getCheckpoint('Xero:getInvoices');
-        expect(checkpoint?.recordCount).toBe(100);
-    });
-    it('lists all checkpoints', async () => {
-        await store.recordSync({ key: 'A', syncedAt: new Date() });
-        await store.recordSync({ key: 'B', syncedAt: new Date() });
-        const all = await store.list();
-        expect(all).toHaveLength(2);
-    });
-    it('clears specific checkpoint', async () => {
-        await store.recordSync({ key: 'A', syncedAt: new Date() });
-        await store.recordSync({ key: 'B', syncedAt: new Date() });
-        await store.clear('A');
-        expect(await store.getCheckpoint('A')).toBeNull();
-        expect(await store.getCheckpoint('B')).not.toBeNull();
-    });
-    it('clears all checkpoints', async () => {
-        await store.recordSync({ key: 'A', syncedAt: new Date() });
-        await store.recordSync({ key: 'B', syncedAt: new Date() });
-        await store.clearAll();
-        const all = await store.list();
-        expect(all).toHaveLength(0);
-    });
-});
-describe('FileSyncStore', () => {
-    let store;
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true });
-        }
-        store = new FileSyncStore('test-mission', TEST_DIR);
-    });
-    afterEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true });
-        }
-    });
-    it('creates sync directory', async () => {
-        // Trigger initialization by calling any async method
-        await store.list();
-        expect(existsSync(TEST_DIR)).toBe(true);
-    });
-    it('persists checkpoints to disk', async () => {
-        const syncedAt = new Date();
-        await store.recordSync({
-            key: 'test-key',
-            syncedAt,
-            recordCount: 50,
-        });
-        // Create new store instance
-        const newStore = new FileSyncStore('test-mission', TEST_DIR);
-        const checkpoint = await newStore.getCheckpoint('test-key');
-        expect(checkpoint).not.toBeNull();
-        expect(checkpoint?.syncedAt.getTime()).toBe(syncedAt.getTime());
-        expect(checkpoint?.recordCount).toBe(50);
-    });
-});
-describe('Parser: since config', () => {
-    function parse(source) {
-        const lexer = new ReqonLexer(source);
-        const tokens = lexer.tokenize();
-        const parser = new ReqonParser(tokens);
-        return parser.parse();
-    }
-    it('parses since: lastSync', () => {
-        const source = `
-      mission Test {
-        source API { auth: bearer, base: "https://api.example.com" }
-        store items: memory("items")
-
-        action Fetch {
-          fetch GET "/items" {
-            since: lastSync
-          }
-          store response -> items { key: .id }
-        }
-
-        run Fetch
-      }
-    `;
-        const program = parse(source);
-        const mission = program.statements[0];
-        const fetch = mission.actions[0].steps[0];
-        expect(fetch.since).toBeDefined();
-        expect(fetch.since?.type).toBe('lastSync');
-    });
-    it('parses since: lastSync("custom-key")', () => {
-        const source = `
-      mission Test {
-        source API { auth: bearer, base: "https://api.example.com" }
-        store items: memory("items")
-
-        action Fetch {
-          fetch GET "/items" {
-            since: lastSync("my-custom-key")
-          }
-          store response -> items { key: .id }
-        }
-
-        run Fetch
-      }
-    `;
-        const program = parse(source);
-        const mission = program.statements[0];
-        const fetch = mission.actions[0].steps[0];
-        expect(fetch.since?.type).toBe('lastSync');
-        expect(fetch.since?.key).toBe('my-custom-key');
-    });
-    it('parses since: lastSync with options', () => {
-        const source = `
-      mission Test {
-        source API { auth: bearer, base: "https://api.example.com" }
-        store items: memory("items")
-
-        action Fetch {
-          fetch GET "/items" {
-            since: lastSync {
-              param: "modified_since",
-              format: unix
-            }
-          }
-          store response -> items { key: .id }
-        }
-
-        run Fetch
-      }
-    `;
-        const program = parse(source);
-        const mission = program.statements[0];
-        const fetch = mission.actions[0].steps[0];
-        expect(fetch.since?.type).toBe('lastSync');
-        expect(fetch.since?.param).toBe('modified_since');
-        expect(fetch.since?.format).toBe('unix');
-    });
-});

package/docusaurus/README.md

@@ -1,41 +0,0 @@
-# Website
-
-This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
-
-## Installation
-
-```bash
-yarn
-```
-
-## Local Development
-
-```bash
-yarn start
-```
-
-This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
-
-## Build
-
-```bash
-yarn build
-```
-
-This command generates static content into the `build` directory and can be served using any static contents hosting service.
-
-## Deployment
-
-Using SSH:
-
-```bash
-USE_SSH=true yarn deploy
-```
-
-Not using SSH:
-
-```bash
-GIT_USER=<Your GitHub username> yarn deploy
-```
-
-If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

package/docusaurus/docs/advanced/execution-state.md

@@ -1,283 +0,0 @@
----
-sidebar_position: 2
----
-
-# Execution State
-
-Reqon maintains execution state for resumable missions and audit trails.
-
-## State Storage
-
-State is stored in `.vague-data/`:
-
-```
-.vague-data/
-├── execution/
-│   ├── CustomerSync-2024-01-20T09-00-00.json
-│   └── CustomerSync-2024-01-20T10-00-00.json
-├── sync-checkpoints.json
-└── stores/
-```
-
-## Execution Record
-
-Each execution creates a record:
-
-```json
-{
-  "executionId": "exec_abc123",
-  "mission": "CustomerSync",
-  "startedAt": "2024-01-20T09:00:00Z",
-  "completedAt": "2024-01-20T09:02:30Z",
-  "status": "completed",
-  "actionsRun": ["FetchCustomers", "TransformCustomers"],
-  "errors": [],
-  "stores": {
-    "customers": {
-      "count": 1523,
-      "added": 42,
-      "updated": 18
-    }
-  }
-}
-```
-
-## State Fields
-
-| Field | Description |
-|-------|-------------|
-| `executionId` | Unique execution identifier |
-| `mission` | Mission name |
-| `startedAt` | Start timestamp |
-| `completedAt` | Completion timestamp |
-| `status` | `running`, `completed`, `failed`, `interrupted` |
-| `actionsRun` | Actions that completed |
-| `activeStep` | Currently running step (if in progress) |
-| `errors` | Array of errors encountered |
-
-## Checkpoints
-
-### Sync Checkpoints
-
-Track incremental sync progress:
-
-```json
-{
-  "API-/customers": {
-    "lastSync": "2024-01-20T09:00:00Z",
-    "itemsSynced": 1523
-  },
-  "API-/orders": {
-    "lastSync": "2024-01-20T08:45:00Z",
-    "itemsSynced": 8721
-  }
-}
-```
-
-### Action Checkpoints
-
-Track progress within long-running actions:
-
-```json
-{
-  "FetchCustomers": {
-    "page": 15,
-    "itemsProcessed": 1500
-  }
-}
-```
-
-## Resumable Execution
-
-### Automatic Resume
-
-If a mission is interrupted, Reqon can resume:
-
-```bash
-reqon ./missions/ --resume
-```
-
-### Resume Point Detection
-
-```json
-{
-  "executionId": "exec_abc123",
-  "status": "interrupted",
-  "activeStep": {
-    "action": "TransformCustomers",
-    "index": 523,
-    "item": { "id": "cust_524" }
-  }
-}
-```
-
-Resume starts from `item 523` in `TransformCustomers`.
-
-## Accessing State
-
-### Programmatically
-
-```typescript
-import { execute, getExecutionState } from 'reqon';
-
-// Get last execution
-const lastState = await getExecutionState('CustomerSync');
-
-// Get specific execution
-const state = await getExecutionState('CustomerSync', 'exec_abc123');
-
-// Get all executions
-const history = await getExecutionHistory('CustomerSync', { limit: 10 });
-```
-
-### Via CLI
-
-```bash
-# Show last execution
-reqon status CustomerSync
-
-# Show execution history
-reqon history CustomerSync --limit 10
-
-# Show specific execution
-reqon status CustomerSync --execution exec_abc123
-```
-
-## State Cleanup
-
-### Automatic Cleanup
-
-```vague
-mission CustomerSync {
-  stateRetention: 7 days  // Keep 7 days of history
-}
-```
-
-### Manual Cleanup
-
-```bash
-# Clear old state
-reqon cleanup --older-than 30d
-
-# Clear specific mission
-reqon cleanup CustomerSync --all
-```
-
-## Monitoring
-
-### Execution Callbacks
-
-```typescript
-import { execute } from 'reqon';
-
-const result = await execute(source, {
-  progressCallbacks: {
-    onActionStart: (action) => {
-      console.log(`Starting: ${action}`);
-    },
-    onActionComplete: (action, duration) => {
-      console.log(`Completed: ${action} in ${duration}ms`);
-    },
-    onError: (error) => {
-      console.error(`Error: ${error.message}`);
-    },
-    onProgress: (progress) => {
-      console.log(`Progress: ${progress.current}/${progress.total}`);
-    }
-  }
-});
-```
-
-### Metrics Export
-
-```bash
-reqon ./missions/ --daemon --metrics-port 9090
-```
-
-Exposes Prometheus metrics:
-
-```
-reqon_execution_duration_seconds{mission="CustomerSync"}
-reqon_execution_items_processed{mission="CustomerSync"}
-reqon_execution_errors_total{mission="CustomerSync"}
-```
-
-## State Persistence
-
-### File-Based (Default)
-
-```vague
-mission CustomerSync {
-  stateStore: file  // Default
-}
-```
-
-### Custom State Store
-
-```typescript
-import { execute, setStateStore } from 'reqon';
-
-setStateStore({
-  async save(state) {
-    await database.insert('execution_state', state);
-  },
-  async load(executionId) {
-    return database.findOne('execution_state', { executionId });
-  }
-});
-```
-
-## Best Practices
-
-### Enable for Long-Running Missions
-
-```vague
-mission LongSync {
-  enableState: true
-  stateRetention: 30 days
-}
-```
-
-### Use Checkpoints for Large Datasets
-
-```vague
-action ProcessLargeDataset {
-  for item in items checkpoint every 100 {
-    // State saved every 100 items
-  }
-}
-```
-
-### Monitor Execution Health
-
-```bash
-# Set up alerting for failed executions
-reqon ./missions/ --daemon --alert-on-failure
-```
-
-## Troubleshooting
-
-### State Not Persisting
-
-Check directory permissions:
-
-```bash
-ls -la .vague-data/
-```
-
-### Resume Not Working
-
-Verify state file exists:
-
-```bash
-cat .vague-data/execution/CustomerSync-*.json | jq '.status'
-```
-
-### State Too Large
-
-Reduce retention or clean up:
-
-```bash
-du -sh .vague-data/
-reqon cleanup --older-than 7d
-```