@hazeljs/data 0.2.0-alpha.1

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

@@ -0,0 +1,319 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const etl_service_1 = require("./etl.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const decorators_1 = require("../decorators");
+const schema_1 = require("../schema/schema");
+let TestPipeline = class TestPipeline {
+    double(data) {
+        const n = data.x;
+        return { x: n * 2 };
+    }
+    validate(data) {
+        return data;
+    }
+    add(data) {
+        return { ...data, y: 10 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'double' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestPipeline.prototype, "double", null);
+__decorate([
+    (0, decorators_1.Validate)({
+        step: 2,
+        name: 'validate',
+        schema: schema_1.Schema.object({ x: schema_1.Schema.number().min(0) }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestPipeline.prototype, "validate", null);
+__decorate([
+    (0, decorators_1.Transform)({ step: 3, name: 'add' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestPipeline.prototype, "add", null);
+TestPipeline = __decorate([
+    (0, decorators_1.Pipeline)('test-pipeline')
+], TestPipeline);
+let TransformOnlyPipeline = class TransformOnlyPipeline {
+    a(data) {
+        return { ...data, a: 1 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'a' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TransformOnlyPipeline.prototype, "a", null);
+TransformOnlyPipeline = __decorate([
+    (0, decorators_1.Pipeline)('transform-only')
+], TransformOnlyPipeline);
+let NoStepsPipeline = class NoStepsPipeline {
+};
+NoStepsPipeline = __decorate([
+    (0, decorators_1.Pipeline)('no-steps')
+], NoStepsPipeline);
+describe('ETLService', () => {
+    let etlService;
+    beforeEach(() => {
+        etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+    });
+    it('executes pipeline steps sequentially', async () => {
+        const pipeline = new TestPipeline();
+        const result = await etlService.execute(pipeline, { x: 5 });
+        expect(result).toEqual({ x: 10, y: 10 });
+    });
+    it('extractSteps returns sorted steps', () => {
+        const pipeline = new TestPipeline();
+        const steps = etlService.extractSteps(pipeline);
+        expect(steps).toHaveLength(3);
+        expect(steps[0].step).toBe(1);
+        expect(steps[1].step).toBe(2);
+        expect(steps[2].step).toBe(3);
+    });
+    it('throws when pipeline has no steps', async () => {
+        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();
+    });
+    it('extractSteps returns only transform/validate steps', () => {
+        const pipeline = new TransformOnlyPipeline();
+        const steps = etlService.extractSteps(pipeline);
+        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.base.d.ts

@@ -0,0 +1,24 @@
+import { ETLService } from './etl.service';
+/**
+ * Base class for pipelines - provides execute() method
+ * Extend this when using @Pipeline decorator for convenient execution
+ *
+ * @example
+ * ```typescript
+ * @Pipeline('user-enrichment')
+ * @Injectable()
+ * export class UserEnrichmentPipeline extends PipelineBase {
+ *   constructor(etlService: ETLService) {
+ *     super(etlService);
+ *   }
+ *   @Transform({ step: 1, name: 'normalize' }) async normalize(data) { ... }
+ * }
+ * // Usage: await pipeline.execute(rawUserData);
+ * ```
+ */
+export declare abstract class PipelineBase {
+    protected readonly etlService: ETLService;
+    constructor(etlService: ETLService);
+    execute<T = unknown>(input: unknown): Promise<T>;
+}
+//# sourceMappingURL=pipeline.base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.base.d.ts","sourceRoot":"","sources":["../../src/pipelines/pipeline.base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,YAAY;IACpB,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU;gBAAtB,UAAU,EAAE,UAAU;IAE/C,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;CAGvD"}

package/dist/pipelines/pipeline.base.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineBase = void 0;
+/**
+ * Base class for pipelines - provides execute() method
+ * Extend this when using @Pipeline decorator for convenient execution
+ *
+ * @example
+ * ```typescript
+ * @Pipeline('user-enrichment')
+ * @Injectable()
+ * export class UserEnrichmentPipeline extends PipelineBase {
+ *   constructor(etlService: ETLService) {
+ *     super(etlService);
+ *   }
+ *   @Transform({ step: 1, name: 'normalize' }) async normalize(data) { ... }
+ * }
+ * // Usage: await pipeline.execute(rawUserData);
+ * ```
+ */
+class PipelineBase {
+    constructor(etlService) {
+        this.etlService = etlService;
+    }
+    async execute(input) {
+        return this.etlService.execute(this, input);
+    }
+}
+exports.PipelineBase = PipelineBase;

package/dist/pipelines/pipeline.base.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipeline.base.test.d.ts.map

package/dist/pipelines/pipeline.base.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.base.test.d.ts","sourceRoot":"","sources":["../../src/pipelines/pipeline.base.test.ts"],"names":[],"mappings":""}

package/dist/pipelines/pipeline.base.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_base_1 = require("./pipeline.base");
+const etl_service_1 = require("./etl.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const decorators_1 = require("../decorators");
+let TestPipeline = class TestPipeline extends pipeline_base_1.PipelineBase {
+    double(data) {
+        const x = data.x;
+        return { x: x * 2 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'double' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestPipeline.prototype, "double", null);
+TestPipeline = __decorate([
+    (0, decorators_1.Pipeline)('base-test')
+], TestPipeline);
+describe('PipelineBase', () => {
+    it('execute runs pipeline via ETLService', async () => {
+        const etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+        const pipeline = new TestPipeline(etlService);
+        const result = await pipeline.execute({ x: 5 });
+        expect(result).toEqual({ x: 10 });
+    });
+});

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

@@ -0,0 +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?: 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[];
+}
+/**
+ * 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 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>;
+    /** 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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.builder.d.ts","sourceRoot":"","sources":["../../src/pipelines/pipeline.builder.ts"],"names":[],"mappings":"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"}