ai-workflows 1.0.0 → 2.0.0

package/test/workflow.test.ts

@@ -0,0 +1,288 @@
+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<number>('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/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/vitest.config.ts

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

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 AI Primitives
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -1,9 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { add } from './index.js';
-describe('add', () => {
-    it('should add two numbers correctly', () => {
-        expect(add(2, 3)).toBe(5);
-        expect(add(-1, 1)).toBe(0);
-        expect(add(0, 0)).toBe(0);
-    });
-});