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

package/dist/telemetry/telemetry.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * Telemetry — zero-dependency OpenTelemetry-compatible instrumentation.
+ *
+ * Works in two modes:
+ *  1. **Standalone** — emits structured events to an in-memory log / custom exporters.
+ *  2. **OTel** — when @opentelemetry/api is present in the host application,
+ *     wraps each pipeline step in an OTel span automatically.
+ *
+ * The package itself does NOT list @opentelemetry/* as dependencies; it uses
+ * dynamic optional `require()` so the feature activates transparently when
+ * the host already has it installed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryService = void 0;
+exports.createPrometheusExporter = createPrometheusExporter;
+function generateId(len = 16) {
+    const chars = '0123456789abcdef';
+    return Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+}
+function simpleHash(value) {
+    const str = JSON.stringify(value) ?? '';
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash) ^ str.charCodeAt(i);
+        hash = hash >>> 0;
+    }
+    return hash.toString(16);
+}
+/**
+ * TelemetryService — collect spans, metrics, and lineage for pipeline executions.
+ *
+ * @example
+ * const telemetry = TelemetryService.getInstance();
+ * telemetry.addSpanExporter((span) => console.log(span));
+ * telemetry.enableLineage();
+ *
+ * // Automatically used by ETLService when registered
+ * DataModule.forRoot({ telemetry: { enabled: true, serviceName: 'orders-pipeline' } });
+ */
+class TelemetryService {
+    constructor(options = {}) {
+        this.spanExporters = [];
+        this.metricExporters = [];
+        this.spans = [];
+        this.metrics = [];
+        this.lineageStore = [];
+        this.lineageEnabled = false;
+        // Loaded lazily if @opentelemetry/api is present in the host app
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.otelApi = null;
+        this.serviceName = options.serviceName ?? 'hazeljs-pipeline';
+        this.maxSpansInMemory = options.maxSpansInMemory ?? 1000;
+        this.tryLoadOtel();
+    }
+    static getInstance(options) {
+        if (!TelemetryService.instance) {
+            TelemetryService.instance = new TelemetryService(options);
+        }
+        return TelemetryService.instance;
+    }
+    static reset() {
+        TelemetryService.instance = null;
+    }
+    tryLoadOtel() {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            this.otelApi = require('@opentelemetry/api');
+        }
+        catch {
+            this.otelApi = null;
+        }
+    }
+    // ─── Configuration ────────────────────────────────────────────────────────
+    addSpanExporter(exporter) {
+        this.spanExporters.push(exporter);
+        return this;
+    }
+    addMetricExporter(exporter) {
+        this.metricExporters.push(exporter);
+        return this;
+    }
+    enableLineage() {
+        this.lineageEnabled = true;
+        return this;
+    }
+    // ─── Span Tracking ────────────────────────────────────────────────────────
+    startTrace(_pipelineName) {
+        const traceId = generateId(32);
+        const rootSpanId = generateId(16);
+        return { traceId, rootSpanId };
+    }
+    async recordSpan(span) {
+        const full = {
+            traceId: span.traceId ?? generateId(32),
+            spanId: span.spanId ?? generateId(16),
+            ...span,
+        };
+        if (this.spans.length >= this.maxSpansInMemory) {
+            this.spans.shift();
+        }
+        this.spans.push(full);
+        // OTel integration
+        if (this.otelApi) {
+            try {
+                const tracer = this.otelApi['trace'].getTracer(this.serviceName);
+                const otelSpan = tracer.startSpan(`pipeline.${full.pipeline}.step.${full.step}`, {
+                    startTime: full.startTime,
+                });
+                otelSpan.setAttributes({
+                    'hazel.pipeline': full.pipeline,
+                    'hazel.step': full.step,
+                    'hazel.step.name': full.stepName,
+                    'hazel.service': this.serviceName,
+                    ...full.attributes,
+                });
+                if (full.status === 'error' && full.error) {
+                    otelSpan.recordException(new Error(full.error));
+                    otelSpan.setStatus({ code: 2, message: full.error });
+                }
+                otelSpan.end(full.endTime);
+            }
+            catch {
+                /* OTel not properly configured */
+            }
+        }
+        for (const exporter of this.spanExporters) {
+            try {
+                await Promise.resolve(exporter(full));
+            }
+            catch {
+                /* noop */
+            }
+        }
+    }
+    // ─── Metrics ──────────────────────────────────────────────────────────────
+    async recordMetric(name, value, labels = {}) {
+        const point = {
+            name,
+            value,
+            labels: { service: this.serviceName, ...labels },
+            timestamp: Date.now(),
+        };
+        this.metrics.push(point);
+        for (const exporter of this.metricExporters) {
+            try {
+                await Promise.resolve(exporter(point));
+            }
+            catch {
+                /* noop */
+            }
+        }
+    }
+    async recordStepMetrics(pipeline, stepName, durationMs, success, recordCount = 1) {
+        const labels = { pipeline, step: stepName };
+        await this.recordMetric('hazel.pipeline.step.duration_ms', durationMs, labels);
+        await this.recordMetric('hazel.pipeline.step.records', recordCount, labels);
+        await this.recordMetric('hazel.pipeline.step.errors', success ? 0 : 1, labels);
+        if (durationMs > 0 && recordCount > 0) {
+            await this.recordMetric('hazel.pipeline.step.throughput', (recordCount / durationMs) * 1000, labels);
+        }
+    }
+    // ─── Lineage ──────────────────────────────────────────────────────────────
+    startLineage(pipeline, input) {
+        return {
+            traceId: generateId(32),
+            pipeline,
+            input,
+            steps: [],
+            output: undefined,
+            timestamp: new Date(),
+        };
+    }
+    recordLineageStep(entry, step, name, input, output, durationMs) {
+        if (!this.lineageEnabled)
+            return;
+        entry.steps.push({
+            step,
+            name,
+            inputHash: simpleHash(input),
+            outputHash: simpleHash(output),
+            durationMs,
+        });
+    }
+    finalizeLineage(entry, output) {
+        if (!this.lineageEnabled)
+            return;
+        entry.output = output;
+        this.lineageStore.push(entry);
+    }
+    // ─── Inspection ───────────────────────────────────────────────────────────
+    getSpans(pipeline) {
+        return pipeline ? this.spans.filter((s) => s.pipeline === pipeline) : [...this.spans];
+    }
+    getMetrics(name) {
+        return name ? this.metrics.filter((m) => m.name === name) : [...this.metrics];
+    }
+    getLineage(traceId) {
+        return traceId
+            ? this.lineageStore.filter((e) => e.traceId === traceId)
+            : [...this.lineageStore];
+    }
+    /** Compute summary stats for a pipeline across all recorded spans. */
+    getSummary(pipeline) {
+        const pipelineSpans = this.spans.filter((s) => s.pipeline === pipeline && s.step === 0);
+        if (pipelineSpans.length === 0)
+            return { totalRuns: 0, successRate: 0, avgDurationMs: 0, p95DurationMs: 0 };
+        const durations = pipelineSpans.map((s) => s.durationMs).sort((a, b) => a - b);
+        const successes = pipelineSpans.filter((s) => s.status === 'ok').length;
+        const p95Idx = Math.floor(durations.length * 0.95);
+        return {
+            totalRuns: pipelineSpans.length,
+            successRate: parseFloat(((successes / pipelineSpans.length) * 100).toFixed(2)),
+            avgDurationMs: parseFloat((durations.reduce((a, b) => a + b, 0) / durations.length).toFixed(2)),
+            p95DurationMs: durations[p95Idx] ?? durations[durations.length - 1],
+        };
+    }
+    clear() {
+        this.spans = [];
+        this.metrics = [];
+        this.lineageStore = [];
+    }
+}
+exports.TelemetryService = TelemetryService;
+TelemetryService.instance = null;
+/**
+ * Prometheus-format metric exporter factory.
+ * Returns a metric exporter that formats points as Prometheus text.
+ *
+ * @example
+ * const { exporter, getText } = createPrometheusExporter();
+ * telemetry.addMetricExporter(exporter);
+ * // GET /metrics → getText()
+ */
+function createPrometheusExporter() {
+    const store = new Map();
+    const exporter = (metric) => {
+        const existing = store.get(metric.name) ?? [];
+        existing.push(metric);
+        if (existing.length > 1000)
+            existing.shift();
+        store.set(metric.name, existing);
+    };
+    const getText = () => {
+        const lines = [];
+        for (const [name, points] of store) {
+            const promName = name.replace(/\./g, '_').replace(/-/g, '_');
+            lines.push(`# TYPE ${promName} gauge`);
+            for (const p of points.slice(-1)) {
+                const labels = Object.entries(p.labels)
+                    .map(([k, v]) => `${k}="${v}"`)
+                    .join(',');
+                lines.push(`${promName}{${labels}} ${p.value} ${p.timestamp}`);
+            }
+        }
+        return lines.join('\n');
+    };
+    return { exporter, getText };
+}

package/dist/telemetry/telemetry.test.d.ts

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

package/dist/telemetry/telemetry.test.d.ts.map

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

package/dist/telemetry/telemetry.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = require("./telemetry");
+describe('TelemetryService', () => {
+    let telemetry;
+    beforeEach(() => {
+        telemetry_1.TelemetryService.reset();
+        telemetry = telemetry_1.TelemetryService.getInstance({ serviceName: 'test-pipeline' });
+        telemetry.clear();
+    });
+    it('records span', async () => {
+        await telemetry.recordSpan({
+            traceId: 't1',
+            spanId: 's1',
+            pipeline: 'orders',
+            step: 1,
+            stepName: 'validate',
+            startTime: 0,
+            endTime: 100,
+            durationMs: 100,
+            status: 'ok',
+            attributes: {},
+        });
+        const spans = telemetry.getSpans('orders');
+        expect(spans).toHaveLength(1);
+        expect(spans[0].durationMs).toBe(100);
+    });
+    it('records metric', async () => {
+        await telemetry.recordMetric('test.metric', 42, { env: 'test' });
+        const metrics = telemetry.getMetrics('test.metric');
+        expect(metrics).toHaveLength(1);
+        expect(metrics[0].value).toBe(42);
+    });
+    it('records step metrics', async () => {
+        await telemetry.recordStepMetrics('orders', 'validate', 50, true, 10);
+        const metrics = telemetry.getMetrics('hazel.pipeline.step.duration_ms');
+        expect(metrics.length).toBeGreaterThanOrEqual(1);
+    });
+    it('getSummary returns pipeline stats', () => {
+        telemetry.getSpans(); // ensure we have data structure
+        const summary = telemetry.getSummary('orders');
+        expect(summary).toHaveProperty('totalRuns');
+        expect(summary).toHaveProperty('successRate');
+    });
+    it('createPrometheusExporter returns exporter and getText', () => {
+        const { exporter, getText } = (0, telemetry_1.createPrometheusExporter)();
+        exporter({ name: 'test', value: 1, labels: {}, timestamp: Date.now() });
+        const text = getText();
+        expect(text).toContain('test');
+    });
+});

package/dist/testing/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Testing utilities for @hazeljs/data pipelines.
+ *
+ * - SchemaFaker: generate fake data from schemas
+ * - PipelineTestHarness: run pipelines and capture per-step events
+ * - MockSource / MockSink: use MemorySource and MemorySink from connectors
+ */
+export { SchemaFaker } from './schema-faker';
+export { PipelineTestHarness } from './pipeline-test-harness';
+export type { StepSnapshot, PipelineRunResult } from './pipeline-test-harness';
+export { MemorySource as MockSource, MemorySink as MockSink } from '../connectors/memory.connector';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG/E,OAAO,EAAE,YAAY,IAAI,UAAU,EAAE,UAAU,IAAI,QAAQ,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Testing utilities for @hazeljs/data pipelines.
+ *
+ * - SchemaFaker: generate fake data from schemas
+ * - PipelineTestHarness: run pipelines and capture per-step events
+ * - MockSource / MockSink: use MemorySource and MemorySink from connectors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockSink = exports.MockSource = exports.PipelineTestHarness = exports.SchemaFaker = void 0;
+var schema_faker_1 = require("./schema-faker");
+Object.defineProperty(exports, "SchemaFaker", { enumerable: true, get: function () { return schema_faker_1.SchemaFaker; } });
+var pipeline_test_harness_1 = require("./pipeline-test-harness");
+Object.defineProperty(exports, "PipelineTestHarness", { enumerable: true, get: function () { return pipeline_test_harness_1.PipelineTestHarness; } });
+// Re-export in-memory connectors as mock source/sink for tests
+var memory_connector_1 = require("../connectors/memory.connector");
+Object.defineProperty(exports, "MockSource", { enumerable: true, get: function () { return memory_connector_1.MemorySource; } });
+Object.defineProperty(exports, "MockSink", { enumerable: true, get: function () { return memory_connector_1.MemorySink; } });

package/dist/testing/pipeline-test-harness.d.ts

@@ -0,0 +1,40 @@
+import type { ETLService } from '../pipelines/etl.service';
+export interface StepSnapshot {
+    step: number;
+    stepName: string;
+    durationMs: number;
+    success: boolean;
+    skipped?: boolean;
+    error?: string;
+}
+export interface PipelineRunResult<T = unknown> {
+    result: T;
+    events: StepSnapshot[];
+    durationMs: number;
+}
+/**
+ * Test harness for pipeline execution.
+ * Wraps a pipeline, runs it, and captures per-step execution events.
+ *
+ * @example
+ * const harness = PipelineTestHarness.create(etlService, myPipeline);
+ * const { result, events } = await harness.run({ raw: 'data' });
+ * expect(events.every(e => e.success)).toBe(true);
+ */
+export declare class PipelineTestHarness {
+    private readonly etlService;
+    private readonly pipelineInstance;
+    private events;
+    constructor(etlService: ETLService, pipelineInstance: object);
+    /**
+     * Run the pipeline with the given input.
+     */
+    run<T = unknown>(input: unknown): Promise<PipelineRunResult<T>>;
+    /**
+     * Run the pipeline and assert no step failed.
+     * Throws if any step failed.
+     */
+    runAndAssertSuccess<T = unknown>(input: unknown): Promise<T>;
+    static create(etlService: ETLService, pipelineInstance: object): PipelineTestHarness;
+}
+//# sourceMappingURL=pipeline-test-harness.d.ts.map

package/dist/testing/pipeline-test-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-test-harness.d.ts","sourceRoot":"","sources":["../../src/testing/pipeline-test-harness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAG3D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC5C,MAAM,EAAE,CAAC,CAAC;IACV,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAJnC,OAAO,CAAC,MAAM,CAAsB;gBAGjB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,MAAM;IAc3C;;OAEG;IACG,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAQrE;;;OAGG;IACG,mBAAmB,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAWlE,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,mBAAmB;CAGrF"}

package/dist/testing/pipeline-test-harness.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineTestHarness = void 0;
+/**
+ * Test harness for pipeline execution.
+ * Wraps a pipeline, runs it, and captures per-step execution events.
+ *
+ * @example
+ * const harness = PipelineTestHarness.create(etlService, myPipeline);
+ * const { result, events } = await harness.run({ raw: 'data' });
+ * expect(events.every(e => e.success)).toBe(true);
+ */
+class PipelineTestHarness {
+    constructor(etlService, pipelineInstance) {
+        this.etlService = etlService;
+        this.pipelineInstance = pipelineInstance;
+        this.events = [];
+        this.etlService.onStepComplete((e) => {
+            this.events.push({
+                step: e.step,
+                stepName: e.stepName,
+                durationMs: e.durationMs,
+                success: e.success,
+                skipped: e.skipped,
+                error: e.error,
+            });
+        });
+    }
+    /**
+     * Run the pipeline with the given input.
+     */
+    async run(input) {
+        this.events = [];
+        const t0 = Date.now();
+        const result = await this.etlService.execute(this.pipelineInstance, input);
+        const durationMs = Date.now() - t0;
+        return { result, events: [...this.events], durationMs };
+    }
+    /**
+     * Run the pipeline and assert no step failed.
+     * Throws if any step failed.
+     */
+    async runAndAssertSuccess(input) {
+        const { result, events } = await this.run(input);
+        const failed = events.filter((e) => !e.success && !e.skipped);
+        if (failed.length > 0) {
+            throw new Error(`Pipeline steps failed: ${failed.map((e) => `${e.stepName}: ${e.error}`).join('; ')}`);
+        }
+        return result;
+    }
+    static create(etlService, pipelineInstance) {
+        return new PipelineTestHarness(etlService, pipelineInstance);
+    }
+}
+exports.PipelineTestHarness = PipelineTestHarness;

package/dist/testing/pipeline-test-harness.test.d.ts

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

package/dist/testing/pipeline-test-harness.test.d.ts.map

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

package/dist/testing/pipeline-test-harness.test.js

@@ -0,0 +1,102 @@
+"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 decorators_1 = require("../decorators");
+const etl_service_1 = require("../pipelines/etl.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const pipeline_test_harness_1 = require("./pipeline-test-harness");
+let TestPipeline = class TestPipeline {
+    double(data) {
+        return { ...data, x: data.x * 2 };
+    }
+    add(data) {
+        return { ...data, x: data.x + 1 };
+    }
+};
+__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.Transform)({ step: 2, 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)('TestPipeline')
+], TestPipeline);
+describe('PipelineTestHarness', () => {
+    it('runs pipeline and captures events', async () => {
+        const schemaValidator = new schema_validator_1.SchemaValidator();
+        const etlService = new etl_service_1.ETLService(schemaValidator);
+        const pipeline = new TestPipeline();
+        const harness = pipeline_test_harness_1.PipelineTestHarness.create(etlService, pipeline);
+        const { result, events, durationMs } = await harness.run({ x: 5 });
+        expect(result).toEqual({ x: 11 });
+        expect(events).toHaveLength(2);
+        expect(events.every((e) => e.success)).toBe(true);
+        expect(durationMs).toBeGreaterThanOrEqual(0);
+    });
+    it('runAndAssertSuccess returns result', async () => {
+        const schemaValidator = new schema_validator_1.SchemaValidator();
+        const etlService = new etl_service_1.ETLService(schemaValidator);
+        const harness = pipeline_test_harness_1.PipelineTestHarness.create(etlService, new TestPipeline());
+        const result = await harness.runAndAssertSuccess({ x: 1 });
+        expect(result.x).toBe(3);
+    });
+    it('runAndAssertSuccess throws when step fails', async () => {
+        let FailingPipeline = class FailingPipeline {
+            fail() {
+                throw new Error('Step failed');
+            }
+        };
+        __decorate([
+            (0, decorators_1.Transform)({ step: 1, name: 'fail' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], FailingPipeline.prototype, "fail", null);
+        FailingPipeline = __decorate([
+            (0, decorators_1.Pipeline)('FailingPipeline')
+        ], FailingPipeline);
+        const schemaValidator = new schema_validator_1.SchemaValidator();
+        const etlService = new etl_service_1.ETLService(schemaValidator);
+        const harness = pipeline_test_harness_1.PipelineTestHarness.create(etlService, new FailingPipeline());
+        await expect(harness.runAndAssertSuccess({})).rejects.toThrow('Step failed');
+    });
+    it('runAndAssertSuccess throws when step fails with DLQ (events show failure)', async () => {
+        let DLQFailingPipeline = class DLQFailingPipeline {
+            fail() {
+                throw new Error('DLQ step failed');
+            }
+        };
+        __decorate([
+            (0, decorators_1.Transform)({
+                step: 1,
+                name: 'fail',
+                dlq: { handler: () => { } },
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], DLQFailingPipeline.prototype, "fail", null);
+        DLQFailingPipeline = __decorate([
+            (0, decorators_1.Pipeline)('DLQFailingPipeline')
+        ], DLQFailingPipeline);
+        const schemaValidator = new schema_validator_1.SchemaValidator();
+        const etlService = new etl_service_1.ETLService(schemaValidator);
+        const harness = pipeline_test_harness_1.PipelineTestHarness.create(etlService, new DLQFailingPipeline());
+        await expect(harness.runAndAssertSuccess({})).rejects.toThrow('Pipeline steps failed');
+    });
+});

package/dist/testing/schema-faker.d.ts

@@ -0,0 +1,32 @@
+import type { BaseSchema } from '../schema/schema';
+/**
+ * Generate fake data that matches a schema.
+ * Uses schema.toJsonSchema() to infer structure and produce valid sample data.
+ *
+ * @example
+ * const UserSchema = Schema.object({ name: Schema.string(), age: Schema.number() });
+ * const fake = SchemaFaker.generate(UserSchema);
+ * // { name: "random-string-123", age: 42 }
+ */
+export declare class SchemaFaker {
+    private readonly options;
+    constructor(options?: {
+        arrayMinLength?: number;
+        arrayMaxLength?: number;
+    });
+    /**
+     * Generate one fake record matching the schema.
+     */
+    generate<T>(schema: BaseSchema<T>): T;
+    /**
+     * Generate N fake records.
+     */
+    generateMany<T>(schema: BaseSchema<T>, count: number): T[];
+    private generateFromJsonSchema;
+    private genByType;
+    private randomString;
+    /** Static convenience method */
+    static generate<T>(schema: BaseSchema<T>): T;
+    static generateMany<T>(schema: BaseSchema<T>, count: number): T[];
+}
+//# sourceMappingURL=schema-faker.d.ts.map

package/dist/testing/schema-faker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-faker.d.ts","sourceRoot":"","sources":["../../src/testing/schema-faker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuD;gBAEnE,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAO;IAI9E;;OAEG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;IAKrC;;OAEG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE;IAI1D,OAAO,CAAC,sBAAsB;IAuC9B,OAAO,CAAC,SAAS;IAkBjB,OAAO,CAAC,YAAY;IAQpB,gCAAgC;IAChC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;IAI5C,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,EAAE;CAGlE"}