Sequential Workflows

import { Step } from '@siglo/core';

export const parseInvoice = Step.create('parseInvoice', async (param: { rawText: string }) => {
    const lines = param.rawText.split('\n');
    return {
        lineCount: lines.length,
        parsedAt: Date.now(),
    };
});

import { Step, flow } from '@siglo/core';

const validateInput = Step.create('validate', async (param: { email: string }) => {
    if (!param.email.includes('@')) throw new Error('Invalid email');
    return { emailValid: true };
});

const createAccount = Step.create('createAccount', async (param: { email: string }) => {
    return { accountId: 'acc_123' };
});

const sendWelcomeEmail = Step.create('sendEmail', async (param: { email: string; accountId: string }) => {
    return { emailSent: true };
});

export const signupWorkflow = flow(validateInput, createAccount, sendWelcomeEmail);

const registerUser = Step.create('register', async param => ({ registered: true }))
    .spec('email', { require: true })
    .spec('age', { custom: val => val >= 18 })
    .strict();

const notifyVip = Step.create('notifyVip', async (param: any) => ({ notified: true })).onBefore(
    param => param.isVip === true,
);

const chargeCard = Step.create('chargeCard', async () => ({ charged: true }))
    .onBefore(param => param.amount > 0)
    .onSkip(() => ({ charged: false, reason: 'Zero amount order' }));

const fetchRate = Step.create('fetchRate', async () => ({ rate: 1.25 })).onAfter((output, param) => ({
    ...output,
    calculatedTotal: param.base * output.rate,
}));

const fetchExchangeRates = Step.create('fetchRates', async () => {
    return { EUR: 1.08, GBP: 1.26 };
}).cache(60000); // Cached for 60 seconds

import { Step, flow } from '@siglo/core';

const step1 = Step.create('add', (p: { x: number }) => ({ x: p.x + 10 }));
const step2 = Step.create('multiply', (p: { x: number }) => ({ result: p.x * 2 }));

const pipeline = flow(step1, step2);
const output = await pipeline.run({ x: 5 });
console.log(output.result); // 30

import { Step, flow, ValidationException } from '@siglo/core';

const strictStep = Step.create('strictStep', (param: { age: number }) => {
    if (param.age < 0) throw new Error('Invalid age');
    return { valid: true };
})
    .spec('age', { require: true })
    .strict();

const wf = flow(strictStep);

try {
    // Missing required field 'age' throws ValidationException
    await wf.run({} as any);
} catch (err: any) {
    if (err instanceof ValidationException) {
        console.error('Validation Error in step:', err.stepName);
        console.error('Violations:', err.message);
    }
}

import { expect } from 'chai';
import { createWorkflowHarness } from '@siglo/testing';
import { Step, flow } from '@siglo/core';

const s1 = Step.create('step1', () => ({ a: 'hello' }));
const s2 = Step.create('step2', (p: { a: string }) => ({ b: `${p.a} world` }));
const wf = flow(s1, s2);

describe('Sequential Workflows Suite', () => {
    it('executes steps in sequence and records trace phases', async () => {
        const harness = createWorkflowHarness(wf);
        const result = await harness.run();

        expect(result.b).to.equal('hello world');

        // Harness trace records both start and complete phases for each step
        expect(harness.getTrace().map(t => `${t.stepName}:${t.phase}`)).to.deep.equal([
            'step1:start',
            'step1:complete',
            'step2:start',
            'step2:complete',
        ]);

        // Assert built-in step execution counts
        harness.assertStepExecuted('step1', 1);
        harness.assertStepExecuted('step2', 1);
    });
});