ai-workflows 2.1.3 → 2.4.0

package/test/every.test.js

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { every, registerScheduleHandler, getScheduleHandlers, clearScheduleHandlers, toCron, intervalToMs, formatInterval, setCronConverter, } from '../src/every.js';
-describe('every - schedule handler registration', () => {
-    beforeEach(() => {
-        clearScheduleHandlers();
-    });
-    describe('every.interval pattern', () => {
-        it('should register handler for every.hour', () => {
-            const handler = () => { };
-            every.hour(handler);
-            const handlers = getScheduleHandlers();
-            expect(handlers).toHaveLength(1);
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 * * * *',
-                natural: 'hour',
-            });
-            expect(handlers[0]?.source).toBeDefined();
-        });
-        it('should register handler for every.day', () => {
-            every.day(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * *',
-                natural: 'day',
-            });
-        });
-        it('should register handler for every.minute', () => {
-            every.minute(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '* * * * *',
-                natural: 'minute',
-            });
-        });
-        it('should register handler for every.week', () => {
-            every.week(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 0',
-                natural: 'week',
-            });
-        });
-    });
-    describe('every.Day pattern', () => {
-        it('should register handler for every.Monday', () => {
-            every.Monday(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 1',
-                natural: 'Monday',
-            });
-        });
-        it('should register handler for every.Friday', () => {
-            every.Friday(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 5',
-                natural: 'Friday',
-            });
-        });
-        it('should register handler for every.weekday', () => {
-            every.weekday(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 1-5',
-                natural: 'weekday',
-            });
-        });
-        it('should register handler for every.weekend', () => {
-            every.weekend(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 0,6',
-                natural: 'weekend',
-            });
-        });
-    });
-    describe('every.Day.atTime pattern', () => {
-        it('should register handler for every.Monday.at9am', () => {
-            every.Monday.at9am(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 9 * * 1',
-                natural: 'Monday.at9am',
-            });
-        });
-        it('should register handler for every.Friday.at5pm', () => {
-            every.Friday.at5pm(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 17 * * 5',
-                natural: 'Friday.at5pm',
-            });
-        });
-        it('should register handler for every.weekday.at8am', () => {
-            every.weekday.at8am(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 8 * * 1-5',
-                natural: 'weekday.at8am',
-            });
-        });
-        it('should register handler for every.Thursday.atnoon', () => {
-            every.Thursday.atnoon(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 12 * * 4',
-                natural: 'Thursday.atnoon',
-            });
-        });
-        it('should register handler for every.Sunday.atmidnight', () => {
-            every.Sunday.atmidnight(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 0 * * 0',
-                natural: 'Sunday.atmidnight',
-            });
-        });
-    });
-    describe('every.units(value) pattern', () => {
-        it('should register handler for every.minutes(30)', () => {
-            every.minutes(30)(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'minute',
-                value: 30,
-                natural: '30 minutes',
-            });
-        });
-        it('should register handler for every.hours(4)', () => {
-            every.hours(4)(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'hour',
-                value: 4,
-                natural: '4 hours',
-            });
-        });
-        it('should register handler for every.seconds(10)', () => {
-            every.seconds(10)(() => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'second',
-                value: 10,
-                natural: '10 seconds',
-            });
-        });
-    });
-    describe('every(natural language) pattern', () => {
-        it('should register handler with natural language description', () => {
-            every('first Monday of the month at 9am', () => { });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.interval).toEqual({
-                type: 'natural',
-                description: 'first Monday of the month at 9am',
-            });
-        });
-        it('should capture source code', () => {
-            every('weekly', async ($) => {
-                $.log('weekly task');
-            });
-            const handlers = getScheduleHandlers();
-            expect(handlers[0]?.source).toContain('$.log');
-        });
-    });
-    describe('registerScheduleHandler', () => {
-        it('should register handler directly', () => {
-            const handler = () => { };
-            registerScheduleHandler({ type: 'hour', value: 2 }, handler);
-            const handlers = getScheduleHandlers();
-            expect(handlers).toHaveLength(1);
-            expect(handlers[0]?.interval).toEqual({ type: 'hour', value: 2 });
-        });
-    });
-    describe('clearScheduleHandlers', () => {
-        it('should clear all handlers', () => {
-            every.hour(() => { });
-            every.day(() => { });
-            expect(getScheduleHandlers()).toHaveLength(2);
-            clearScheduleHandlers();
-            expect(getScheduleHandlers()).toHaveLength(0);
-        });
-    });
-});
-describe('toCron', () => {
-    it('should return known patterns directly', async () => {
-        expect(await toCron('hour')).toBe('0 * * * *');
-        expect(await toCron('day')).toBe('0 0 * * *');
-        expect(await toCron('Monday')).toBe('0 0 * * 1');
-        expect(await toCron('weekday')).toBe('0 0 * * 1-5');
-    });
-    it('should return cron expression if already valid', async () => {
-        expect(await toCron('0 9 * * 1-5')).toBe('0 9 * * 1-5');
-        expect(await toCron('*/15 * * * *')).toBe('*/15 * * * *');
-    });
-    it('should throw for unknown patterns without converter', async () => {
-        await expect(toCron('every 15 minutes during business hours')).rejects.toThrow('Unknown schedule pattern');
-    });
-    it('should use custom converter when set', async () => {
-        setCronConverter(async (desc) => {
-            if (desc.includes('business hours')) {
-                return '*/15 9-17 * * 1-5';
-            }
-            return '* * * * *';
-        });
-        expect(await toCron('every 15 minutes during business hours')).toBe('*/15 9-17 * * 1-5');
-        // Reset converter
-        setCronConverter(async () => '* * * * *');
-    });
-});
-describe('intervalToMs', () => {
-    it('should convert second intervals', () => {
-        expect(intervalToMs({ type: 'second' })).toBe(1000);
-        expect(intervalToMs({ type: 'second', value: 5 })).toBe(5000);
-    });
-    it('should convert minute intervals', () => {
-        expect(intervalToMs({ type: 'minute' })).toBe(60000);
-        expect(intervalToMs({ type: 'minute', value: 30 })).toBe(1800000);
-    });
-    it('should convert hour intervals', () => {
-        expect(intervalToMs({ type: 'hour' })).toBe(3600000);
-        expect(intervalToMs({ type: 'hour', value: 4 })).toBe(14400000);
-    });
-    it('should convert day intervals', () => {
-        expect(intervalToMs({ type: 'day' })).toBe(86400000);
-        expect(intervalToMs({ type: 'day', value: 2 })).toBe(172800000);
-    });
-    it('should convert week intervals', () => {
-        expect(intervalToMs({ type: 'week' })).toBe(604800000);
-        expect(intervalToMs({ type: 'week', value: 2 })).toBe(1209600000);
-    });
-    it('should return 0 for cron intervals', () => {
-        expect(intervalToMs({ type: 'cron', expression: '0 * * * *' })).toBe(0);
-    });
-    it('should return 0 for natural intervals', () => {
-        expect(intervalToMs({ type: 'natural', description: 'every hour' })).toBe(0);
-    });
-});
-describe('formatInterval', () => {
-    it('should format second intervals', () => {
-        expect(formatInterval({ type: 'second' })).toBe('every second');
-        expect(formatInterval({ type: 'second', value: 5 })).toBe('every 5 seconds');
-    });
-    it('should format minute intervals', () => {
-        expect(formatInterval({ type: 'minute' })).toBe('every minute');
-        expect(formatInterval({ type: 'minute', value: 30 })).toBe('every 30 minutes');
-    });
-    it('should format hour intervals', () => {
-        expect(formatInterval({ type: 'hour' })).toBe('every hour');
-        expect(formatInterval({ type: 'hour', value: 4 })).toBe('every 4 hours');
-    });
-    it('should format day intervals', () => {
-        expect(formatInterval({ type: 'day' })).toBe('every day');
-        expect(formatInterval({ type: 'day', value: 2 })).toBe('every 2 days');
-    });
-    it('should format week intervals', () => {
-        expect(formatInterval({ type: 'week' })).toBe('every week');
-        expect(formatInterval({ type: 'week', value: 2 })).toBe('every 2 weeks');
-    });
-    it('should format cron intervals', () => {
-        expect(formatInterval({ type: 'cron', expression: '0 9 * * 1' })).toBe('cron: 0 9 * * 1');
-    });
-    it('should format natural intervals', () => {
-        expect(formatInterval({ type: 'natural', description: 'every hour during business hours' })).toBe('every hour during business hours');
-    });
-    it('should use natural description when available', () => {
-        expect(formatInterval({ type: 'cron', expression: '0 9 * * 1', natural: 'Monday.at9am' })).toBe('Monday.at9am');
-    });
-});

package/test/on.test.js

@@ -1,80 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { on, registerEventHandler, getEventHandlers, clearEventHandlers } from '../src/on.js';
-describe('on - event handler registration', () => {
-    beforeEach(() => {
-        clearEventHandlers();
-    });
-    describe('on.Noun.event pattern', () => {
-        it('should register handler for Customer.created', () => {
-            const handler = () => { };
-            on.Customer.created(handler);
-            const handlers = getEventHandlers();
-            expect(handlers).toHaveLength(1);
-            expect(handlers[0]?.noun).toBe('Customer');
-            expect(handlers[0]?.event).toBe('created');
-            expect(handlers[0]?.handler).toBe(handler);
-            expect(handlers[0]?.source).toBeDefined();
-        });
-        it('should register handler for Order.completed', () => {
-            const handler = () => { };
-            on.Order.completed(handler);
-            const handlers = getEventHandlers();
-            expect(handlers).toHaveLength(1);
-            expect(handlers[0]?.noun).toBe('Order');
-            expect(handlers[0]?.event).toBe('completed');
-        });
-        it('should register multiple handlers', () => {
-            on.Customer.created(() => { });
-            on.Customer.updated(() => { });
-            on.Order.completed(() => { });
-            const handlers = getEventHandlers();
-            expect(handlers).toHaveLength(3);
-        });
-        it('should register multiple handlers for same event', () => {
-            on.Customer.created(() => { });
-            on.Customer.created(() => { });
-            const handlers = getEventHandlers();
-            expect(handlers).toHaveLength(2);
-            expect(handlers[0]?.noun).toBe('Customer');
-            expect(handlers[0]?.event).toBe('created');
-            expect(handlers[1]?.noun).toBe('Customer');
-            expect(handlers[1]?.event).toBe('created');
-        });
-        it('should capture function source code', () => {
-            on.Test.event(async (data, $) => {
-                $.log('test', data);
-            });
-            const handlers = getEventHandlers();
-            expect(handlers[0]?.source).toContain('$.log');
-        });
-    });
-    describe('registerEventHandler', () => {
-        it('should register handler directly', () => {
-            const handler = () => { };
-            registerEventHandler('Payment', 'failed', handler);
-            const handlers = getEventHandlers();
-            expect(handlers).toHaveLength(1);
-            expect(handlers[0]?.noun).toBe('Payment');
-            expect(handlers[0]?.event).toBe('failed');
-            expect(handlers[0]?.handler).toBe(handler);
-        });
-    });
-    describe('clearEventHandlers', () => {
-        it('should clear all handlers', () => {
-            on.Customer.created(() => { });
-            on.Order.completed(() => { });
-            expect(getEventHandlers()).toHaveLength(2);
-            clearEventHandlers();
-            expect(getEventHandlers()).toHaveLength(0);
-        });
-    });
-    describe('getEventHandlers', () => {
-        it('should return a copy of handlers array', () => {
-            on.Customer.created(() => { });
-            const handlers1 = getEventHandlers();
-            const handlers2 = getEventHandlers();
-            expect(handlers1).not.toBe(handlers2);
-            expect(handlers1).toEqual(handlers2);
-        });
-    });
-});

package/test/send.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { send, parseEvent } from '../src/send.js';
-import { on, clearEventHandlers } from '../src/on.js';
-describe('send - event emission', () => {
-    beforeEach(() => {
-        clearEventHandlers();
-    });
-    describe('parseEvent', () => {
-        it('should parse valid event strings', () => {
-            expect(parseEvent('Customer.created')).toEqual({
-                noun: 'Customer',
-                event: 'created',
-            });
-            expect(parseEvent('Order.completed')).toEqual({
-                noun: 'Order',
-                event: 'completed',
-            });
-            expect(parseEvent('Payment.failed')).toEqual({
-                noun: 'Payment',
-                event: 'failed',
-            });
-        });
-        it('should return null for invalid event strings', () => {
-            expect(parseEvent('invalid')).toBeNull();
-            expect(parseEvent('too.many.parts')).toBeNull();
-            expect(parseEvent('')).toBeNull();
-            expect(parseEvent('.')).toBeNull();
-        });
-    });
-    describe('send', () => {
-        it('should emit event to registered handler', async () => {
-            const handler = vi.fn();
-            on.Customer.created(handler);
-            await send('Customer.created', { id: '123', name: 'John' });
-            expect(handler).toHaveBeenCalledTimes(1);
-            expect(handler).toHaveBeenCalledWith({ id: '123', name: 'John' }, expect.objectContaining({
-                send: expect.any(Function),
-                getState: expect.any(Function),
-                set: expect.any(Function),
-                get: expect.any(Function),
-                log: expect.any(Function),
-            }));
-        });
-        it('should emit event to multiple handlers', async () => {
-            const handler1 = vi.fn();
-            const handler2 = vi.fn();
-            on.Customer.created(handler1);
-            on.Customer.created(handler2);
-            await send('Customer.created', { id: '123' });
-            expect(handler1).toHaveBeenCalledTimes(1);
-            expect(handler2).toHaveBeenCalledTimes(1);
-        });
-        it('should not throw when no handlers are registered', async () => {
-            await expect(send('Customer.created', { id: '123' })).resolves.not.toThrow();
-        });
-        it('should not call handlers for different events', async () => {
-            const handler = vi.fn();
-            on.Customer.updated(handler);
-            await send('Customer.created', { id: '123' });
-            expect(handler).not.toHaveBeenCalled();
-        });
-        it('should not call handlers for different nouns', async () => {
-            const handler = vi.fn();
-            on.Order.created(handler);
-            await send('Customer.created', { id: '123' });
-            expect(handler).not.toHaveBeenCalled();
-        });
-        it('should handle async handlers', async () => {
-            let completed = false;
-            on.Customer.created(async () => {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                completed = true;
-            });
-            await send('Customer.created', { id: '123' });
-            expect(completed).toBe(true);
-        });
-        it('should continue with other handlers if one throws', async () => {
-            const handler1 = vi.fn().mockRejectedValue(new Error('Handler 1 failed'));
-            const handler2 = vi.fn();
-            on.Customer.created(handler1);
-            on.Customer.created(handler2);
-            // Should not throw
-            await expect(send('Customer.created', { id: '123' })).resolves.not.toThrow();
-            // Both handlers should be called
-            expect(handler1).toHaveBeenCalledTimes(1);
-            expect(handler2).toHaveBeenCalledTimes(1);
-        });
-    });
-});

package/test/workflow.test.js

@@ -1,224 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { Workflow, createTestContext, parseEvent } from '../src/workflow.js';
-import { clearEventHandlers } from '../src/on.js';
-import { clearScheduleHandlers } from '../src/every.js';
-describe('Workflow - unified $ API', () => {
-    beforeEach(() => {
-        clearEventHandlers();
-        clearScheduleHandlers();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    describe('Workflow()', () => {
-        it('should create a workflow with $ context', () => {
-            const workflow = Workflow($ => {
-                // Just accessing $ to verify it works
-                expect($).toBeDefined();
-                expect($.on).toBeDefined();
-                expect($.every).toBeDefined();
-                expect($.send).toBeDefined();
-                expect($.log).toBeDefined();
-                expect($.get).toBeDefined();
-                expect($.set).toBeDefined();
-                expect($.getState).toBeDefined();
-            });
-            expect(workflow).toBeDefined();
-            expect(workflow.$).toBeDefined();
-            expect(workflow.send).toBeDefined();
-            expect(workflow.start).toBeDefined();
-            expect(workflow.stop).toBeDefined();
-        });
-        it('should capture event handlers registered via $.on', () => {
-            const workflow = Workflow($ => {
-                $.on.Customer.created(() => { });
-                $.on.Order.completed(() => { });
-            });
-            expect(workflow.definition.events).toHaveLength(2);
-            expect(workflow.definition.events[0]?.noun).toBe('Customer');
-            expect(workflow.definition.events[0]?.event).toBe('created');
-            expect(workflow.definition.events[1]?.noun).toBe('Order');
-            expect(workflow.definition.events[1]?.event).toBe('completed');
-        });
-        it('should capture schedule handlers registered via $.every', () => {
-            const workflow = Workflow($ => {
-                $.every.hour(() => { });
-                $.every.Monday.at9am(() => { });
-            });
-            expect(workflow.definition.schedules).toHaveLength(2);
-        });
-        it('should capture function source code', () => {
-            const workflow = Workflow($ => {
-                $.on.Test.event(async (data, ctx) => {
-                    ctx.log('Test event', data);
-                });
-            });
-            // Source code is captured (variable names may be minified)
-            expect(workflow.definition.events[0]?.source).toBeDefined();
-            expect(workflow.definition.events[0]?.source.length).toBeGreaterThan(0);
-            expect(workflow.definition.events[0]?.source).toContain('Test event');
-        });
-        it('should deliver events to registered handlers', async () => {
-            const handler = vi.fn();
-            const workflow = Workflow($ => {
-                $.on.Customer.created(handler);
-            });
-            await workflow.start();
-            await workflow.send('Customer.created', { id: '123', name: 'John' });
-            expect(handler).toHaveBeenCalledTimes(1);
-            expect(handler).toHaveBeenCalledWith({ id: '123', name: 'John' }, expect.objectContaining({
-                send: expect.any(Function),
-                log: expect.any(Function),
-            }));
-        });
-        it('should allow chained event sending from handlers', async () => {
-            const welcomeHandler = vi.fn();
-            const workflow = Workflow($ => {
-                $.on.Customer.created(async (customer, $) => {
-                    await $.send('Email.welcome', { to: customer.email });
-                });
-                $.on.Email.welcome(welcomeHandler);
-            });
-            await workflow.start();
-            await workflow.send('Customer.created', { name: 'John', email: 'john@example.com' });
-            expect(welcomeHandler).toHaveBeenCalledWith({ to: 'john@example.com' }, expect.anything());
-        });
-        it('should track events in state history', async () => {
-            const workflow = Workflow($ => {
-                $.on.Test.event(() => { });
-            });
-            await workflow.start();
-            await workflow.send('Test.event', { data: 'test' });
-            expect(workflow.state.history).toHaveLength(1);
-            expect(workflow.state.history[0]).toMatchObject({
-                type: 'event',
-                name: 'Test.event',
-                data: { data: 'test' },
-            });
-        });
-        it('should trigger schedule handlers', async () => {
-            const handler = vi.fn();
-            const workflow = Workflow($ => {
-                $.every.seconds(1)(handler);
-            });
-            await workflow.start();
-            await vi.advanceTimersByTimeAsync(1000);
-            expect(handler).toHaveBeenCalledTimes(1);
-            await vi.advanceTimersByTimeAsync(1000);
-            expect(handler).toHaveBeenCalledTimes(2);
-            await workflow.stop();
-        });
-        it('should stop schedule handlers on stop', async () => {
-            const handler = vi.fn();
-            const workflow = Workflow($ => {
-                $.every.seconds(1)(handler);
-            });
-            await workflow.start();
-            await vi.advanceTimersByTimeAsync(1000);
-            expect(handler).toHaveBeenCalledTimes(1);
-            await workflow.stop();
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it('should support $.set and $.get for context data', async () => {
-            const workflow = Workflow($ => {
-                $.on.Test.set(async (data, $) => {
-                    $.set('value', data.value);
-                });
-                $.on.Test.get(async (_, $) => {
-                    const value = $.get('value');
-                    $.log('Got value', value);
-                });
-            });
-            await workflow.start();
-            await workflow.send('Test.set', { value: 42 });
-            expect(workflow.state.context.value).toBe(42);
-            expect(workflow.$.get('value')).toBe(42);
-        });
-        it('should use initial context from options', () => {
-            const workflow = Workflow($ => { }, { context: { counter: 100 } });
-            expect(workflow.state.context.counter).toBe(100);
-        });
-    });
-    describe('parseEvent', () => {
-        it('should parse valid event strings', () => {
-            expect(parseEvent('Customer.created')).toEqual({
-                noun: 'Customer',
-                event: 'created',
-            });
-        });
-        it('should return null for invalid event strings', () => {
-            expect(parseEvent('invalid')).toBeNull();
-            expect(parseEvent('too.many.parts')).toBeNull();
-            expect(parseEvent('')).toBeNull();
-        });
-    });
-    describe('createTestContext', () => {
-        it('should create a $ context for testing', () => {
-            const $ = createTestContext();
-            expect($.send).toBeDefined();
-            expect($.on).toBeDefined();
-            expect($.every).toBeDefined();
-            expect($.log).toBeDefined();
-            expect($.get).toBeDefined();
-            expect($.set).toBeDefined();
-            expect($.getState).toBeDefined();
-            expect($.emittedEvents).toBeDefined();
-        });
-        it('should track emitted events', async () => {
-            const $ = createTestContext();
-            await $.send('Test.event1', { a: 1 });
-            await $.send('Test.event2', { b: 2 });
-            expect($.emittedEvents).toHaveLength(2);
-            expect($.emittedEvents[0]).toEqual({ event: 'Test.event1', data: { a: 1 } });
-            expect($.emittedEvents[1]).toEqual({ event: 'Test.event2', data: { b: 2 } });
-        });
-        it('should support get/set', () => {
-            const $ = createTestContext();
-            $.set('key', 'value');
-            expect($.get('key')).toBe('value');
-        });
-    });
-    describe('$.every patterns', () => {
-        it('should support $.every.hour', () => {
-            const workflow = Workflow($ => {
-                $.every.hour(() => { });
-            });
-            expect(workflow.definition.schedules[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 * * * *',
-                natural: 'hour',
-            });
-        });
-        it('should support $.every.Monday.at9am', () => {
-            const workflow = Workflow($ => {
-                $.every.Monday.at9am(() => { });
-            });
-            expect(workflow.definition.schedules[0]?.interval).toEqual({
-                type: 'cron',
-                expression: '0 9 * * 1',
-                natural: 'Monday.at9am',
-            });
-        });
-        it('should support $.every.minutes(30)', () => {
-            const workflow = Workflow($ => {
-                $.every.minutes(30)(() => { });
-            });
-            expect(workflow.definition.schedules[0]?.interval).toEqual({
-                type: 'minute',
-                value: 30,
-                natural: '30 minutes',
-            });
-        });
-        it('should support $.every("natural language")', () => {
-            const workflow = Workflow($ => {
-                $.every('first Monday of the month', () => { });
-            });
-            expect(workflow.definition.schedules[0]?.interval).toEqual({
-                type: 'natural',
-                description: 'first Monday of the month',
-            });
-        });
-    });
-});

package/vitest.config.js

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        globals: true,
-        include: ['test/**/*.test.ts'],
-    },
-});