@hazeljs/data 0.2.0-beta.67 → 0.2.0-beta.69

package/dist/pipelines/etl.service.js

@@ -17,13 +17,67 @@ const core_1 = require("@hazeljs/core");
 const decorators_1 = require("../decorators");
 const schema_validator_1 = require("../validators/schema.validator");
 const core_2 = __importDefault(require("@hazeljs/core"));
+/** Runs a promise with a per-call timeout. */
+async function withTimeout(promise, timeoutMs, stepName) {
+    return new Promise((resolve, reject) => {
+        const id = setTimeout(() => reject(new Error(`Step "${stepName}" timed out after ${timeoutMs}ms`)), timeoutMs);
+        promise.then((v) => {
+            clearTimeout(id);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(id);
+            reject(e);
+        });
+    });
+}
+/** Executes fn with retry + exponential/fixed backoff. */
+async function withRetry(fn, retry, stepName) {
+    const { attempts, delay = 500, backoff = 'fixed' } = retry;
+    let lastError = new Error('Unknown error');
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            if (attempt < attempts) {
+                const wait = backoff === 'exponential' ? delay * Math.pow(2, attempt - 1) : delay;
+                core_2.default.debug(`Step "${stepName}" attempt ${attempt} failed. Retrying in ${wait}ms...`);
+                await new Promise((r) => setTimeout(r, wait));
+            }
+        }
+    }
+    throw lastError;
+}
 /**
- * ETL Service - Orchestrates pipeline execution
- * Executes steps sequentially: output from step N → input to step N+1
+ * ETL Service — orchestrates pipeline execution.
+ *
+ * Features:
+ * - Sequential step execution (output N → input N+1)
+ * - Conditional steps via `when` predicate
+ * - Per-step retry with fixed/exponential backoff
+ * - Per-step execution timeout
+ * - Dead letter queue (DLQ) for graceful failure handling
+ * - Pipeline event hooks for observability
  */
 let ETLService = class ETLService {
     constructor(schemaValidator) {
         this.schemaValidator = schemaValidator;
+        this.eventHandlers = [];
+    }
+    /** Register a handler called after each step completes or fails. */
+    onStepComplete(handler) {
+        this.eventHandlers.push(handler);
+    }
+    emit(event) {
+        for (const h of this.eventHandlers) {
+            try {
+                h(event);
+            }
+            catch {
+                /* noop */
+            }
+        }
     }
     extractSteps(instance) {
         const steps = [];
@@ -41,6 +95,10 @@ let ETLService = class ETLService {
                         name: transformMeta.name,
                         type: 'transform',
                         method: key,
+                        when: transformMeta.when,
+                        retry: transformMeta.retry,
+                        timeoutMs: transformMeta.timeoutMs,
+                        dlq: transformMeta.dlq,
                     });
                 }
                 else if (validateMeta) {
@@ -50,6 +108,10 @@ let ETLService = class ETLService {
                         type: 'validate',
                         method: key,
                         schema: validateMeta.schema,
+                        when: validateMeta.when,
+                        retry: validateMeta.retry,
+                        timeoutMs: validateMeta.timeoutMs,
+                        dlq: validateMeta.dlq,
                     });
                 }
             }
@@ -70,14 +132,89 @@ let ETLService = class ETLService {
             if (typeof fn !== 'function') {
                 throw new Error(`Step ${step.name} method ${step.method} not found`);
             }
-            if (step.type === 'validate' && step.schema) {
-                data = this.schemaValidator.validate(step.schema, data);
+            // Conditional skip
+            if (step.when && !step.when(data)) {
+                core_2.default.debug(`Step "${step.name}" skipped (when predicate returned false)`);
+                this.emit({
+                    pipeline: metadata?.name ?? 'unknown',
+                    step: step.step,
+                    stepName: step.name,
+                    durationMs: 0,
+                    success: true,
+                    skipped: true,
+                });
+                continue;
+            }
+            const t0 = Date.now();
+            const runStep = async () => {
+                if (step.type === 'validate' && step.schema) {
+                    data = this.schemaValidator.validate(step.schema, data);
+                }
+                const result = fn.call(pipelineInstance, data);
+                return result instanceof Promise ? await result : result;
+            };
+            try {
+                let stepPromise = step.retry ? withRetry(runStep, step.retry, step.name) : runStep();
+                if (step.timeoutMs) {
+                    stepPromise = withTimeout(stepPromise, step.timeoutMs, step.name);
+                }
+                data = await stepPromise;
+                this.emit({
+                    pipeline: metadata?.name ?? 'unknown',
+                    step: step.step,
+                    stepName: step.name,
+                    durationMs: Date.now() - t0,
+                    success: true,
+                });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                this.emit({
+                    pipeline: metadata?.name ?? 'unknown',
+                    step: step.step,
+                    stepName: step.name,
+                    durationMs: Date.now() - t0,
+                    success: false,
+                    error: error.message,
+                });
+                if (step.dlq) {
+                    core_2.default.debug(`Step "${step.name}" failed — routing to DLQ`);
+                    await Promise.resolve(step.dlq.handler(data, error, step.name));
+                    // Continue with unchanged data when routed to DLQ
+                }
+                else {
+                    throw error;
+                }
             }
-            const result = fn.call(pipelineInstance, data);
-            data = result instanceof Promise ? await result : result;
         }
         return data;
     }
+    /**
+     * Execute multiple items through the pipeline in parallel.
+     * Items that fail are routed to the DLQ if configured, otherwise they propagate.
+     */
+    async executeBatch(pipelineInstance, items, options = {}) {
+        const { concurrency = 10 } = options;
+        const results = [];
+        const errors = [];
+        for (let i = 0; i < items.length; i += concurrency) {
+            const batch = items.slice(i, i + concurrency);
+            const settled = await Promise.allSettled(batch.map((item) => this.execute(pipelineInstance, item)));
+            for (let j = 0; j < settled.length; j++) {
+                const s = settled[j];
+                if (s.status === 'fulfilled') {
+                    results.push(s.value);
+                }
+                else {
+                    errors.push({
+                        item: batch[j],
+                        error: s.reason instanceof Error ? s.reason : new Error(String(s.reason)),
+                    });
+                }
+            }
+        }
+        return { results, errors };
+    }
 };
 exports.ETLService = ETLService;
 exports.ETLService = ETLService = __decorate([

package/dist/pipelines/etl.service.test.js

@@ -91,6 +91,11 @@ describe('ETLService', () => {
         const pipeline = new NoStepsPipeline();
         await expect(etlService.execute(pipeline, {})).rejects.toThrow('has no steps');
     });
+    it('throws when step method not found on instance', async () => {
+        const pipeline = new TestPipeline();
+        pipeline.double = null;
+        await expect(etlService.execute(pipeline, { x: 5 })).rejects.toThrow('not found');
+    });
     it('validates data at validate step', async () => {
         const pipeline = new TestPipeline();
         await expect(etlService.execute(pipeline, { x: -1 })).rejects.toThrow();
@@ -101,4 +106,214 @@ describe('ETLService', () => {
         expect(steps).toHaveLength(1);
         expect(steps[0].type).toBe('transform');
     });
+    it('onStepComplete emits events for each step', async () => {
+        const events = [];
+        etlService.onStepComplete((e) => events.push({ step: e.step, stepName: e.stepName, success: e.success }));
+        const pipeline = new TestPipeline();
+        await etlService.execute(pipeline, { x: 5 });
+        expect(events).toHaveLength(3);
+        expect(events.every((e) => e.success)).toBe(true);
+        expect(events.map((e) => e.stepName)).toEqual(['double', 'validate', 'add']);
+    });
+    it('executeBatch returns results and errors', async () => {
+        const pipeline = new TestPipeline();
+        const { results, errors } = await etlService.executeBatch(pipeline, [{ x: 1 }, { x: -1 }, { x: 2 }], { concurrency: 2 });
+        expect(results).toHaveLength(2);
+        expect(results[0]).toEqual({ x: 2, y: 10 });
+        expect(results[1]).toEqual({ x: 4, y: 10 });
+        expect(errors).toHaveLength(1);
+        expect(errors[0].item).toEqual({ x: -1 });
+    });
+    it('executeBatch wraps non-Error rejections', async () => {
+        let ThrowStringPipeline = class ThrowStringPipeline {
+            fail() {
+                throw 'string rejection';
+            }
+        };
+        __decorate([
+            (0, decorators_1.Transform)({ step: 1, name: 'fail' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], ThrowStringPipeline.prototype, "fail", null);
+        ThrowStringPipeline = __decorate([
+            (0, decorators_1.Pipeline)('throw-string')
+        ], ThrowStringPipeline);
+        const { errors } = await etlService.executeBatch(new ThrowStringPipeline(), [{}]);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].error).toBeInstanceOf(Error);
+        expect(errors[0].error.message).toContain('string rejection');
+    });
+});
+let ConditionalPipeline = class ConditionalPipeline {
+    always(data) {
+        return { ...data, step: 1 };
+    }
+    whenStep(data) {
+        return { ...data, step: 2 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'always' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ConditionalPipeline.prototype, "always", null);
+__decorate([
+    (0, decorators_1.Transform)({
+        step: 2,
+        name: 'when-true',
+        when: (d) => d.skip !== true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ConditionalPipeline.prototype, "whenStep", null);
+ConditionalPipeline = __decorate([
+    (0, decorators_1.Pipeline)('conditional-pipeline')
+], ConditionalPipeline);
+describe('ETLService conditional steps', () => {
+    let etlService;
+    beforeEach(() => {
+        etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+    });
+    it('skips step when when predicate returns false', async () => {
+        const pipeline = new ConditionalPipeline();
+        const events = [];
+        etlService.onStepComplete((e) => events.push({ stepName: e.stepName, skipped: e.skipped }));
+        const result = await etlService.execute(pipeline, {
+            skip: true,
+        });
+        expect(result.step).toBe(1);
+        expect(events.find((e) => e.stepName === 'when-true')?.skipped).toBe(true);
+    });
+    it('runs step when when predicate returns true', async () => {
+        const pipeline = new ConditionalPipeline();
+        const result = await etlService.execute(pipeline, {});
+        expect(result.step).toBe(2);
+    });
+});
+let RetryPipeline = class RetryPipeline {
+    constructor() {
+        this.attempts = 0;
+    }
+    retryStep(data) {
+        this.attempts++;
+        if (this.attempts < 2)
+            throw new Error('Fail');
+        return { ...data, ok: true };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'retry', retry: { attempts: 3, delay: 10, backoff: 'exponential' } }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], RetryPipeline.prototype, "retryStep", null);
+RetryPipeline = __decorate([
+    (0, decorators_1.Pipeline)('retry-pipeline')
+], RetryPipeline);
+const dlqCaptured = [];
+let DLQPipeline = class DLQPipeline {
+    failStep(data) {
+        if (data.skip)
+            return data;
+        throw new Error('DLQ test error');
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({
+        step: 1,
+        name: 'fail',
+        dlq: {
+            handler: (item, err) => {
+                dlqCaptured.push({ item, error: err.message });
+            },
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], DLQPipeline.prototype, "failStep", null);
+DLQPipeline = __decorate([
+    (0, decorators_1.Pipeline)('dlq-pipeline')
+], DLQPipeline);
+describe('ETLService retry and DLQ', () => {
+    let etlService;
+    beforeEach(() => {
+        etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+        dlqCaptured.length = 0;
+    });
+    it('retries step on failure', async () => {
+        const pipeline = new RetryPipeline();
+        const result = await etlService.execute(pipeline, {});
+        expect(result.ok).toBe(true);
+        expect(pipeline.attempts).toBe(2);
+    });
+    it('dlq receives failed item and pipeline continues with unchanged data', async () => {
+        const pipeline = new DLQPipeline();
+        const result = await etlService.execute(pipeline, { x: 1 });
+        expect(dlqCaptured).toHaveLength(1);
+        expect(dlqCaptured[0].error).toBe('DLQ test error');
+        expect(result).toEqual({ x: 1 });
+    });
+});
+let TimeoutPipeline = class TimeoutPipeline {
+    async slowStep() {
+        await new Promise((r) => setTimeout(r, 200));
+        return { done: true };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'slow', timeoutMs: 50 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TimeoutPipeline.prototype, "slowStep", null);
+TimeoutPipeline = __decorate([
+    (0, decorators_1.Pipeline)('timeout-pipeline')
+], TimeoutPipeline);
+let RetryFixedPipeline = class RetryFixedPipeline {
+    constructor() {
+        this.attempts = 0;
+    }
+    retryStep() {
+        this.attempts++;
+        if (this.attempts < 2)
+            throw new Error('Fail');
+        return { ok: true };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'retry', retry: { attempts: 3, delay: 5, backoff: 'fixed' } }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], RetryFixedPipeline.prototype, "retryStep", null);
+RetryFixedPipeline = __decorate([
+    (0, decorators_1.Pipeline)('retry-fixed')
+], RetryFixedPipeline);
+describe('ETLService timeout and retry fixed', () => {
+    let etlService;
+    beforeEach(() => {
+        etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+    });
+    it('times out when step exceeds timeoutMs', async () => {
+        const pipeline = new TimeoutPipeline();
+        await expect(etlService.execute(pipeline, {})).rejects.toThrow('timed out');
+    });
+    it('retries with fixed backoff', async () => {
+        const pipeline = new RetryFixedPipeline();
+        const result = await etlService.execute(pipeline, {});
+        expect(result.ok).toBe(true);
+        expect(pipeline.attempts).toBe(2);
+    });
+    it('emit catches handler errors', async () => {
+        const pipeline = new TestPipeline();
+        etlService.onStepComplete(() => {
+            throw new Error('Handler error');
+        });
+        const result = await etlService.execute(pipeline, { x: 5 });
+        expect(result).toEqual({ x: 10, y: 10 });
+    });
 });

package/dist/pipelines/pipeline.builder.d.ts

@@ -1,22 +1,95 @@
+import type { RetryConfig, DLQConfig } from '../data.types';
+type TransformFn = (data: unknown) => unknown | Promise<unknown>;
+type ValidateFn = (data: unknown) => unknown;
+type CatchFn = (data: unknown, error: Error) => unknown | Promise<unknown>;
+type ConditionFn = (data: unknown) => boolean;
 export interface PipelineStepConfig {
     name: string;
-    transform?: (data: unknown) => unknown | Promise<unknown>;
-    validate?: (data: unknown) => unknown;
+    transform?: TransformFn;
+    validate?: ValidateFn;
+    catch?: CatchFn;
+    when?: ConditionFn;
+    retry?: RetryConfig;
+    timeoutMs?: number;
+    dlq?: DLQConfig;
+    /** Parallel transforms — all run concurrently, results merged */
+    parallel?: TransformFn[];
+    /** Branch on a condition: truthy → left builder, falsy → right builder */
+    branch?: {
+        condition: ConditionFn;
+        left: PipelineBuilder;
+        right: PipelineBuilder;
+    };
+}
+export interface SerializedStep {
+    name: string;
+    conditional?: boolean;
+    parallel?: boolean;
+    parallelCount?: number;
+    branch?: boolean;
+    retry?: RetryConfig;
+    timeoutMs?: number;
+}
+export interface PipelineDefinition {
+    name: string;
+    steps: SerializedStep[];
 }
 /**
- * Pipeline Builder - DSL for building pipelines programmatically
+ * PipelineBuilder — immutable, fluent DSL for building ETL pipelines programmatically.
+ *
+ * Each builder method returns a **new** instance — the original is never mutated.
+ *
+ * @example
+ * const pipeline = new PipelineBuilder()
+ *   .setName('orders')
+ *   .addTransform('normalize', (d) => ({ ...d, email: d.email.toLowerCase() }))
+ *   .when((d) => d.active, (b) => b.addTransform('enrich', enrich))
+ *   .addValidate('validate', validateFn);
+ *
+ * const result = await pipeline.execute(rawData);
  */
 export declare class PipelineBuilder {
-    private steps;
-    private name;
-    setName(name: string): this;
-    addTransform(name: string, transform: (data: unknown) => unknown | Promise<unknown>): this;
-    addValidate(name: string, validate: (data: unknown) => unknown): this;
+    private readonly _name;
+    private readonly _steps;
+    constructor(name?: string, steps?: PipelineStepConfig[]);
+    setName(name: string): PipelineBuilder;
+    addTransform(name: string, transform: TransformFn, options?: {
+        when?: ConditionFn;
+        retry?: RetryConfig;
+        timeoutMs?: number;
+        dlq?: DLQConfig;
+    }): PipelineBuilder;
+    addValidate(name: string, validate: ValidateFn, options?: {
+        when?: ConditionFn;
+    }): PipelineBuilder;
+    /**
+     * Run multiple transforms concurrently. Results are merged (Object.assign) into
+     * the current data if they are objects, otherwise replaced with an array of results.
+     */
+    parallel(name: string, transforms: TransformFn[]): PipelineBuilder;
+    /**
+     * Conditional branch: if `condition(data)` is true, run `thenBuilder` steps,
+     * otherwise run `elseBuilder` steps (default: identity).
+     */
+    branch(name: string, condition: ConditionFn, thenBuilder: (b: PipelineBuilder) => PipelineBuilder, elseBuilder?: (b: PipelineBuilder) => PipelineBuilder): PipelineBuilder;
+    /**
+     * Attach a per-step error handler. If the previous step throws, `handler` is
+     * called with `(data, error)` and its return value becomes the new data.
+     */
+    catch(handler: CatchFn): PipelineBuilder;
     execute<T = unknown>(input: unknown): Promise<T>;
-    build(): {
-        name: string;
-        steps: PipelineStepConfig[];
-    };
-    reset(): this;
+    /** Serialize the pipeline definition to a plain object (steps with functions are omitted). */
+    toSchema(): PipelineDefinition;
+    build(): PipelineDefinition;
+    /** Create a fresh pipeline from a definition (transforms must be re-registered). */
+    static create(name?: string): PipelineBuilder;
+    /**
+     * @deprecated Use `new PipelineBuilder()` directly. Kept for backward compat.
+     * Note: this instance is now immutable — reset() returns a new empty builder.
+     */
+    reset(): PipelineBuilder;
+    get name(): string;
+    get steps(): ReadonlyArray<PipelineStepConfig>;
 }
+export {};
 //# sourceMappingURL=pipeline.builder.d.ts.map

package/dist/pipelines/pipeline.builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.builder.d.ts","sourceRoot":"","sources":["../../src/pipelines/pipeline.builder.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;CACvC;AAED;;GAEG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,IAAI,CAAsB;IAElC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK3B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;IAK1F,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI;IAK/D,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAkBtD,KAAK,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,kBAAkB,EAAE,CAAA;KAAE;IAItD,KAAK,IAAI,IAAI;CAKd"}
+{"version":3,"file":"pipeline.builder.d.ts","sourceRoot":"","sources":["../../src/pipelines/pipeline.builder.ts"],"names":[],"mappings":"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"}