@hazeljs/data 0.2.0-beta.53 → 0.2.0-beta.55

package/dist/data.module.test.d.ts

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

package/dist/data.module.test.d.ts.map

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

package/dist/data.module.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_module_1 = require("./data.module");
+describe('DataModule', () => {
+    describe('forRoot', () => {
+        it('returns dynamic module structure', () => {
+            const result = data_module_1.DataModule.forRoot();
+            expect(result).toHaveProperty('module', data_module_1.DataModule);
+            expect(result).toHaveProperty('providers');
+            expect(result).toHaveProperty('exports');
+            expect(Array.isArray(result.providers)).toBe(true);
+        });
+        it('includes flink config when specified', () => {
+            const result = data_module_1.DataModule.forRoot({
+                flink: { url: 'http://flink:8081', timeout: 5000 },
+            });
+            const flinkConfig = result.providers.find((p) => p && typeof p === 'object' && 'provide' in p);
+            expect(flinkConfig).toBeDefined();
+        });
+    });
+    describe('getOptions', () => {
+        it('returns last forRoot options', () => {
+            data_module_1.DataModule.forRoot({ flink: { url: 'http://custom:8081' } });
+            const opts = data_module_1.DataModule.getOptions();
+            expect(opts.flink?.url).toBe('http://custom:8081');
+        });
+    });
+});

package/dist/decorators/pipeline.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=pipeline.decorator.test.d.ts.map

package/dist/decorators/pipeline.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/pipeline.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/pipeline.decorator.test.js

@@ -0,0 +1,96 @@
+"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 });
+require("reflect-metadata");
+const pipeline_decorator_1 = require("./pipeline.decorator");
+const transform_decorator_1 = require("./transform.decorator");
+const validate_decorator_1 = require("./validate.decorator");
+const stream_decorator_1 = require("./stream.decorator");
+const schema_1 = require("../schema/schema");
+describe('Pipeline decorator', () => {
+    it('applies metadata with string name', () => {
+        let TestPipeline = class TestPipeline {
+        };
+        TestPipeline = __decorate([
+            (0, pipeline_decorator_1.Pipeline)('my-pipeline')
+        ], TestPipeline);
+        const meta = (0, pipeline_decorator_1.getPipelineMetadata)(TestPipeline);
+        expect(meta?.name).toBe('my-pipeline');
+        expect((0, pipeline_decorator_1.hasPipelineMetadata)(TestPipeline)).toBe(true);
+    });
+    it('applies metadata with options object', () => {
+        let CustomPipeline = class CustomPipeline {
+        };
+        CustomPipeline = __decorate([
+            (0, pipeline_decorator_1.Pipeline)({ name: 'custom' })
+        ], CustomPipeline);
+        expect((0, pipeline_decorator_1.getPipelineMetadata)(CustomPipeline)?.name).toBe('custom');
+    });
+});
+describe('Transform decorator', () => {
+    it('applies step metadata', () => {
+        class TestClass {
+            normalize() { }
+        }
+        __decorate([
+            (0, transform_decorator_1.Transform)({ step: 1, name: 'normalize' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "normalize", null);
+        const meta = (0, transform_decorator_1.getTransformMetadata)(TestClass.prototype, 'normalize');
+        expect(meta?.step).toBe(1);
+        expect(meta?.name).toBe('normalize');
+        expect(meta?.type).toBe('transform');
+    });
+});
+describe('Validate decorator', () => {
+    it('applies schema metadata', () => {
+        const schema = schema_1.Schema.object({ email: schema_1.Schema.string().email() });
+        class TestClass {
+            validate() { }
+        }
+        __decorate([
+            (0, validate_decorator_1.Validate)({ step: 2, name: 'validate', schema }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "validate", null);
+        const meta = (0, validate_decorator_1.getValidateMetadata)(TestClass.prototype, 'validate');
+        expect(meta?.step).toBe(2);
+        expect(meta?.schema).toBe(schema);
+    });
+});
+describe('Stream decorator', () => {
+    it('applies stream metadata', () => {
+        let StreamPipeline = class StreamPipeline {
+        };
+        StreamPipeline = __decorate([
+            (0, stream_decorator_1.Stream)({
+                name: 'events',
+                source: 'kafka://topic',
+                sink: 'kafka://out',
+                parallelism: 8,
+            })
+        ], StreamPipeline);
+        const meta = (0, stream_decorator_1.getStreamMetadata)(StreamPipeline);
+        expect(meta?.name).toBe('events');
+        expect(meta?.source).toBe('kafka://topic');
+        expect(meta?.sink).toBe('kafka://out');
+        expect(meta?.parallelism).toBe(8);
+        expect((0, stream_decorator_1.hasStreamMetadata)(StreamPipeline)).toBe(true);
+    });
+    it('hasStreamMetadata false for undecorated', () => {
+        class Plain {
+        }
+        expect((0, stream_decorator_1.hasStreamMetadata)(Plain)).toBe(false);
+    });
+});

package/dist/flink.service.js

@@ -80,7 +80,7 @@ let FlinkService = class FlinkService {
 };
 exports.FlinkService = FlinkService;
 exports.FlinkService = FlinkService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [etl_service_1.ETLService,
         stream_builder_1.StreamBuilder])
 ], FlinkService);

package/dist/flink.service.test.d.ts

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

package/dist/flink.service.test.d.ts.map

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

package/dist/flink.service.test.js

@@ -0,0 +1,60 @@
+"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 flink_service_1 = require("./flink.service");
+const etl_service_1 = require("./pipelines/etl.service");
+const stream_builder_1 = require("./streaming/stream.builder");
+const schema_validator_1 = require("./validators/schema.validator");
+const decorators_1 = require("./decorators");
+let TestPipeline = class TestPipeline {
+    a(data) {
+        return data;
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'a' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestPipeline.prototype, "a", null);
+TestPipeline = __decorate([
+    (0, decorators_1.Stream)({ name: 'test', source: 'kafka://in', sink: 'kafka://out', parallelism: 2 })
+], TestPipeline);
+describe('FlinkService', () => {
+    let service;
+    beforeEach(() => {
+        const etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+        const streamBuilder = new stream_builder_1.StreamBuilder(etlService);
+        service = new flink_service_1.FlinkService(etlService, streamBuilder);
+    });
+    it('getClient throws when not configured', () => {
+        expect(() => service.getClient()).toThrow('FlinkService not configured');
+    });
+    it('configure sets up client', () => {
+        service.configure({ url: 'http://flink:8081' });
+        const client = service.getClient();
+        expect(client.url).toBe('http://flink:8081');
+    });
+    it('deployStream returns job config', async () => {
+        service.configure({ url: 'http://localhost:8081' });
+        const pipeline = new TestPipeline();
+        const result = await service.deployStream(pipeline);
+        expect(result.status).toBe('config_generated');
+        expect(result.jobConfig).toBeDefined();
+        expect(result.jobConfig.jobName).toBe('TestPipeline');
+        expect(result.jobGraph).toBeDefined();
+    });
+    it('deployStream with config override', async () => {
+        service.configure({ url: 'http://localhost:8081' });
+        const result = await service.deployStream(new TestPipeline(), { parallelism: 16 });
+        expect(result.jobConfig.parallelism).toBe(16);
+    });
+});

package/dist/pipelines/etl.service.js

@@ -81,6 +81,6 @@ let ETLService = class ETLService {
 };
 exports.ETLService = ETLService;
 exports.ETLService = ETLService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [schema_validator_1.SchemaValidator])
 ], ETLService);

package/dist/pipelines/etl.service.test.d.ts

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

package/dist/pipelines/etl.service.test.d.ts.map

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

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

@@ -0,0 +1,104 @@
+"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('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');
+    });
+});

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.js

@@ -58,5 +58,5 @@ let PipelineBuilder = class PipelineBuilder {
 };
 exports.PipelineBuilder = PipelineBuilder;
 exports.PipelineBuilder = PipelineBuilder = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], PipelineBuilder);

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

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

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_builder_1 = require("./pipeline.builder");
+describe('PipelineBuilder', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new pipeline_builder_1.PipelineBuilder();
+    });
+    it('adds transform and executes', async () => {
+        builder.addTransform('step1', (d) => Object.assign({}, d, { a: 1 }));
+        builder.addTransform('step2', (d) => Object.assign({}, d, { b: 2 }));
+        const result = await builder.execute({ x: 0 });
+        expect(result).toEqual({ x: 0, a: 1, b: 2 });
+    });
+    it('handles async transforms', async () => {
+        builder.addTransform('async', async (d) => Object.assign({}, d, { done: true }));
+        const result = await builder.execute({});
+        expect(result.done).toBe(true);
+    });
+    it('setName sets pipeline name', () => {
+        builder.setName('my-pipeline');
+        const built = builder.build();
+        expect(built.name).toBe('my-pipeline');
+    });
+    it('build returns config', () => {
+        builder.addTransform('s1', (d) => d).addValidate('s2', (d) => d);
+        const config = builder.build();
+        expect(config.steps).toHaveLength(2);
+        expect(config.name).toBe('unnamed-pipeline');
+    });
+    it('reset clears steps', async () => {
+        builder.addTransform('s1', (d) => d);
+        builder.reset();
+        const config = builder.build();
+        expect(config.steps).toHaveLength(0);
+    });
+});

package/dist/pipelines/stream.service.js

@@ -53,6 +53,6 @@ let StreamService = class StreamService {
 };
 exports.StreamService = StreamService;
 exports.StreamService = StreamService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [etl_service_1.ETLService])
 ], StreamService);

package/dist/pipelines/stream.service.test.d.ts

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

package/dist/pipelines/stream.service.test.d.ts.map

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

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

@@ -0,0 +1,54 @@
+"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 stream_service_1 = require("./stream.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const decorators_1 = require("../decorators");
+let BatchTestPipeline = class BatchTestPipeline {
+    inc(data) {
+        return { v: (data.v || 0) + 1 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'inc' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], BatchTestPipeline.prototype, "inc", null);
+BatchTestPipeline = __decorate([
+    (0, decorators_1.Pipeline)('batch-test'),
+    (0, decorators_1.Stream)({ name: 'test', source: 'kafka://in', sink: 'kafka://out' })
+], BatchTestPipeline);
+describe('StreamService', () => {
+    let streamService;
+    beforeEach(() => {
+        const etlService = new etl_service_1.ETLService(new schema_validator_1.SchemaValidator());
+        streamService = new stream_service_1.StreamService(etlService);
+    });
+    it('processes batch of items', async () => {
+        const pipeline = new BatchTestPipeline();
+        const results = await streamService.processBatch(pipeline, [{ v: 0 }, { v: 1 }]);
+        expect(results).toEqual([{ v: 1 }, { v: 2 }]);
+    });
+    it('processStream yields results', async () => {
+        const pipeline = new BatchTestPipeline();
+        async function* source() {
+            yield { v: 0 };
+            yield { v: 5 };
+        }
+        const results = [];
+        for await (const r of streamService.processStream(pipeline, source())) {
+            results.push(r);
+        }
+        expect(results).toEqual([{ v: 1 }, { v: 6 }]);
+    });
+});

package/dist/quality/quality.service.js

@@ -83,5 +83,5 @@ let QualityService = class QualityService {
 };
 exports.QualityService = QualityService;
 exports.QualityService = QualityService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], QualityService);

package/dist/quality/quality.service.test.d.ts

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

package/dist/quality/quality.service.test.d.ts.map

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

package/dist/quality/quality.service.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const quality_service_1 = require("./quality.service");
+describe('QualityService', () => {
+    let service;
+    beforeEach(() => {
+        service = new quality_service_1.QualityService();
+    });
+    it('runs registered checks', async () => {
+        service.registerCheck('custom', (data) => ({
+            name: 'custom',
+            passed: data.ok === true,
+        }));
+        const report = await service.runChecks('test', { ok: true });
+        expect(report.checks).toHaveLength(1);
+        expect(report.checks[0].passed).toBe(true);
+        expect(report.passed).toBe(true);
+    });
+    it('completeness check', () => {
+        const check = service.completeness(['email', 'name']);
+        expect(check({ email: 'a@b.com', name: 'x' }).passed).toBe(true);
+        expect(check({ email: 'a@b.com' }).passed).toBe(false);
+    });
+    it('notNull check', () => {
+        const check = service.notNull(['id']);
+        expect(check({ id: 1 }).passed).toBe(true);
+        expect(check({ id: null }).passed).toBe(false);
+    });
+    it('report includes totalRows', async () => {
+        service.registerCheck('dummy', () => ({ name: 'dummy', passed: true }));
+        const report = await service.runChecks('ds', [{}, {}]);
+        expect(report.totalRows).toBe(2);
+    });
+});

package/dist/schema/schema.test.d.ts

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

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

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

package/dist/schema/schema.test.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("./schema");
+describe('Schema', () => {
+    describe('string', () => {
+        it('validates string', () => {
+            const result = schema_1.Schema.string().validate('hello');
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('hello');
+        });
+        it('rejects non-string', () => {
+            const result = schema_1.Schema.string().validate(123);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Expected string');
+        });
+        it('email validation', () => {
+            expect(schema_1.Schema.string().email().validate('a@b.com').success).toBe(true);
+            expect(schema_1.Schema.string().email().validate('invalid').success).toBe(false);
+        });
+        it('min length', () => {
+            expect(schema_1.Schema.string().min(3).validate('abc').success).toBe(true);
+            expect(schema_1.Schema.string().min(3).validate('ab').success).toBe(false);
+        });
+        it('max length', () => {
+            expect(schema_1.Schema.string().max(3).validate('abc').success).toBe(true);
+            expect(schema_1.Schema.string().max(2).validate('abc').success).toBe(false);
+        });
+        it('uuid validation', () => {
+            const valid = '550e8400-e29b-41d4-a716-446655440000';
+            expect(schema_1.Schema.string().uuid().validate(valid).success).toBe(true);
+            expect(schema_1.Schema.string().uuid().validate('not-uuid').success).toBe(false);
+        });
+        it('oneOf validation', () => {
+            expect(schema_1.Schema.string().oneOf(['a', 'b']).validate('a').success).toBe(true);
+            expect(schema_1.Schema.string().oneOf(['a', 'b']).validate('c').success).toBe(false);
+        });
+    });
+    describe('number', () => {
+        it('validates number', () => {
+            const result = schema_1.Schema.number().validate(42);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('rejects non-number', () => {
+            expect(schema_1.Schema.number().validate('42').success).toBe(false);
+            expect(schema_1.Schema.number().validate(NaN).success).toBe(false);
+        });
+        it('min/max', () => {
+            expect(schema_1.Schema.number().min(0).max(100).validate(50).success).toBe(true);
+            expect(schema_1.Schema.number().min(0).validate(-1).success).toBe(false);
+            expect(schema_1.Schema.number().max(10).validate(11).success).toBe(false);
+        });
+    });
+    describe('date', () => {
+        it('validates Date', () => {
+            const d = new Date();
+            const result = schema_1.Schema.date().validate(d);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(d);
+        });
+        it('validates date string', () => {
+            const result = schema_1.Schema.date().validate('2024-01-01');
+            expect(result.success).toBe(true);
+        });
+        it('rejects invalid date', () => {
+            expect(schema_1.Schema.date().validate('invalid').success).toBe(false);
+            expect(schema_1.Schema.date().validate({}).success).toBe(false);
+        });
+    });
+    describe('object', () => {
+        it('validates object shape', () => {
+            const schema = schema_1.Schema.object({
+                name: schema_1.Schema.string(),
+                age: schema_1.Schema.number(),
+            });
+            const result = schema.validate({ name: 'John', age: 30 });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.name).toBe('John');
+                expect(result.data.age).toBe(30);
+            }
+        });
+        it('rejects invalid fields', () => {
+            const schema = schema_1.Schema.object({
+                age: schema_1.Schema.number(),
+            });
+            const result = schema.validate({ age: 'thirty' });
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors.length).toBeGreaterThan(0);
+        });
+        it('rejects non-object', () => {
+            expect(schema_1.Schema.object({}).validate('str').success).toBe(false);
+            expect(schema_1.Schema.object({}).validate(null).success).toBe(false);
+            expect(schema_1.Schema.object({}).validate([]).success).toBe(false);
+        });
+    });
+    describe('array', () => {
+        it('validates array of items', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const result = schema.validate([1, 2, 3]);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual([1, 2, 3]);
+        });
+        it('rejects invalid items', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const result = schema.validate([1, 'two', 3]);
+            expect(result.success).toBe(false);
+        });
+        it('rejects non-array', () => {
+            expect(schema_1.Schema.array(schema_1.Schema.string()).validate({}).success).toBe(false);
+        });
+    });
+});

package/dist/streaming/flink/flink.client.test.d.ts

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

package/dist/streaming/flink/flink.client.test.d.ts.map

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

package/dist/streaming/flink/flink.client.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flink_client_1 = require("./flink.client");
+// Mock fetch for Flink REST API
+const mockFetch = jest.fn();
+describe('FlinkClient', () => {
+    let client;
+    beforeAll(() => {
+        global.fetch = mockFetch;
+    });
+    beforeEach(() => {
+        mockFetch.mockReset();
+        client = new flink_client_1.FlinkClient({ url: 'http://localhost:8081' });
+    });
+    it('listJobs fetches job overview', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({
+                jobs: [
+                    { id: 'j1', status: 'RUNNING', 'start-time': 123, 'end-time': 456, duration: 100 },
+                ],
+            })),
+        });
+        const jobs = await client.listJobs();
+        expect(jobs).toHaveLength(1);
+        expect(jobs[0].id).toBe('j1');
+        expect(jobs[0].status).toBe('RUNNING');
+        expect(mockFetch).toHaveBeenCalledWith('http://localhost:8081/jobs/overview', expect.any(Object));
+    });
+    it('getJobStatus fetches job details', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({ state: 'RUNNING', 'start-time': 123, duration: 500 })),
+        });
+        const status = await client.getJobStatus('j1');
+        expect(status.state).toBe('RUNNING');
+        expect(status.duration).toBe(500);
+    });
+    it('throws on API error', async () => {
+        mockFetch.mockResolvedValue({ ok: false, text: () => Promise.resolve('Not found') });
+        await expect(client.getJobStatus('bad')).rejects.toThrow('Flink API error');
+    });
+    it('submitJob throws with helpful message', async () => {
+        await expect(client.submitJob({})).rejects.toThrow('submitJob: Full Flink deployment requires');
+    });
+    it('getClusterInfo', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({ taskmanagers: 2, 'slots-total': 8 })),
+        });
+        const info = await client.getClusterInfo();
+        expect(info.taskmanagers).toBe(2);
+    });
+    it('cancelJob', async () => {
+        mockFetch.mockResolvedValue({ ok: true, text: () => Promise.resolve('') });
+        await client.cancelJob('j1');
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('mode=cancel'), expect.any(Object));
+    });
+});

package/dist/streaming/flink/flink.job.test.d.ts

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

package/dist/streaming/flink/flink.job.test.d.ts.map

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

package/dist/streaming/flink/flink.job.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flink_client_1 = require("./flink.client");
+const flink_job_1 = require("./flink.job");
+const mockFetch = jest.fn();
+describe('FlinkJob', () => {
+    let job;
+    beforeAll(() => {
+        global.fetch = mockFetch;
+    });
+    beforeEach(() => {
+        mockFetch.mockReset();
+        const client = new flink_client_1.FlinkClient({ url: 'http://localhost:8081' });
+        job = new flink_job_1.FlinkJob(client);
+    });
+    it('getStatus fetches job status', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({ state: 'RUNNING', duration: 100 })),
+        });
+        const status = await job.getStatus('j1');
+        expect(status.state).toBe('RUNNING');
+    });
+    it('cancel calls cancel endpoint', async () => {
+        mockFetch.mockResolvedValue({ ok: true, text: () => Promise.resolve('') });
+        await job.cancel('j1');
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/jobs/j1'), expect.any(Object));
+    });
+    it('createSavepoint', async () => {
+        mockFetch.mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(JSON.stringify({ 'request-id': 'req-1' })),
+        });
+        const result = await job.createSavepoint('j1', '/path');
+        expect(result['request-id']).toBe('req-1');
+    });
+});

package/dist/streaming/flink/flink.operators.test.d.ts

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

package/dist/streaming/flink/flink.operators.test.d.ts.map

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

package/dist/streaming/flink/flink.operators.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flink_operators_1 = require("./flink.operators");
+describe('flink operators', () => {
+    describe('mapToFlinkOperator', () => {
+        it('maps transform step to map operator', () => {
+            const step = {
+                step: 1,
+                name: 'parse',
+                type: 'transform',
+                method: 'parse',
+            };
+            const op = (0, flink_operators_1.mapToFlinkOperator)(step);
+            expect(op.type).toBe('map');
+            expect(op.step).toBe(1);
+            expect(op.name).toBe('parse');
+        });
+        it('maps validate step to filter operator', () => {
+            const step = {
+                step: 2,
+                name: 'validate',
+                type: 'validate',
+                method: 'validate',
+            };
+            const op = (0, flink_operators_1.mapToFlinkOperator)(step);
+            expect(op.type).toBe('filter');
+        });
+    });
+    describe('createFlinkJobGraph', () => {
+        it('creates job graph with source, sink, transformations', () => {
+            const steps = [{ step: 1, name: 't1', type: 'transform', method: 't1' }];
+            const graph = (0, flink_operators_1.createFlinkJobGraph)(steps, { type: 'kafka', topic: 'in', properties: {} }, { type: 'kafka', topic: 'out', properties: {} });
+            expect(graph.source.topic).toBe('in');
+            expect(graph.sink.topic).toBe('out');
+            expect(graph.transformations).toHaveLength(1);
+        });
+    });
+});

package/dist/streaming/stream.builder.test.d.ts

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

package/dist/streaming/stream.builder.test.d.ts.map

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

package/dist/streaming/stream.builder.test.js

@@ -0,0 +1,59 @@
+"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("../pipelines/etl.service");
+const stream_builder_1 = require("./stream.builder");
+const schema_validator_1 = require("../validators/schema.validator");
+const decorators_1 = require("../decorators");
+let TestStreamPipeline = class TestStreamPipeline {
+    parse(data) {
+        return data;
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'parse' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], TestStreamPipeline.prototype, "parse", null);
+TestStreamPipeline = __decorate([
+    (0, decorators_1.Stream)({
+        name: 'test-stream',
+        source: 'kafka://events',
+        sink: 'kafka://processed',
+        parallelism: 4,
+    })
+], TestStreamPipeline);
+describe('StreamBuilder', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new stream_builder_1.StreamBuilder(new etl_service_1.ETLService(new schema_validator_1.SchemaValidator()));
+    });
+    it('builds config from @Stream pipeline', () => {
+        const pipeline = new TestStreamPipeline();
+        const { jobConfig, jobGraph } = builder.buildConfig(pipeline);
+        expect(jobConfig.jobName).toBe('TestStreamPipeline');
+        expect(jobConfig.parallelism).toBe(4);
+        expect(jobGraph.source.topic).toBe('events');
+        expect(jobGraph.sink.topic).toBe('processed');
+        expect(jobGraph.transformations).toHaveLength(1);
+    });
+    it('allows config override', () => {
+        const pipeline = new TestStreamPipeline();
+        const { jobConfig } = builder.buildConfig(pipeline, { parallelism: 8 });
+        expect(jobConfig.parallelism).toBe(8);
+    });
+    it('throws when pipeline not @Stream decorated', () => {
+        class PlainPipeline {
+        }
+        expect(() => builder.buildConfig(new PlainPipeline())).toThrow('Pipeline must be decorated with @Stream');
+    });
+});

package/dist/streaming/stream.processor.test.d.ts

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

package/dist/streaming/stream.processor.test.d.ts.map

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

package/dist/streaming/stream.processor.test.js

@@ -0,0 +1,52 @@
+"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 stream_processor_1 = require("./stream.processor");
+const etl_service_1 = require("../pipelines/etl.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const decorators_1 = require("../decorators");
+let ProcTestPipeline = class ProcTestPipeline {
+    inc(data) {
+        return { v: (data.v || 0) + 1 };
+    }
+};
+__decorate([
+    (0, decorators_1.Transform)({ step: 1, name: 'inc' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ProcTestPipeline.prototype, "inc", null);
+ProcTestPipeline = __decorate([
+    (0, decorators_1.Pipeline)('proc-test')
+], ProcTestPipeline);
+describe('StreamProcessor', () => {
+    let processor;
+    beforeEach(() => {
+        processor = new stream_processor_1.StreamProcessor(new etl_service_1.ETLService(new schema_validator_1.SchemaValidator()));
+    });
+    it('processItem runs pipeline on single item', async () => {
+        const pipeline = new ProcTestPipeline();
+        const result = await processor.processItem(pipeline, { v: 0 });
+        expect(result).toEqual({ v: 1 });
+    });
+    it('processStream yields processed items', async () => {
+        const pipeline = new ProcTestPipeline();
+        async function* gen() {
+            yield { v: 1 };
+            yield { v: 2 };
+        }
+        const results = [];
+        for await (const r of processor.processStream(pipeline, gen())) {
+            results.push(r);
+        }
+        expect(results).toEqual([{ v: 2 }, { v: 3 }]);
+    });
+});

package/dist/transformers/built-in.transformers.test.d.ts

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

package/dist/transformers/built-in.transformers.test.d.ts.map

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

package/dist/transformers/built-in.transformers.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const built_in_transformers_1 = require("./built-in.transformers");
+describe('built-in transformers', () => {
+    describe('trimString', () => {
+        it('trims whitespace', () => {
+            expect((0, built_in_transformers_1.trimString)('  hi  ')).toBe('hi');
+        });
+        it('converts non-string', () => {
+            expect((0, built_in_transformers_1.trimString)(123)).toBe('123');
+        });
+    });
+    describe('toLowerCase', () => {
+        it('lowercases string', () => {
+            expect((0, built_in_transformers_1.toLowerCase)('HELLO')).toBe('hello');
+        });
+    });
+    describe('toUpperCase', () => {
+        it('uppercases string', () => {
+            expect((0, built_in_transformers_1.toUpperCase)('hello')).toBe('HELLO');
+        });
+    });
+    describe('parseJson', () => {
+        it('parses JSON string', () => {
+            expect((0, built_in_transformers_1.parseJson)('{"a":1}')).toEqual({ a: 1 });
+        });
+        it('returns value for non-string', () => {
+            expect((0, built_in_transformers_1.parseJson)({ a: 1 })).toEqual({ a: 1 });
+        });
+    });
+    describe('stringifyJson', () => {
+        it('stringifies object', () => {
+            expect((0, built_in_transformers_1.stringifyJson)({ a: 1 })).toBe('{"a":1}');
+        });
+    });
+    describe('pick', () => {
+        it('picks specified keys', () => {
+            const fn = (0, built_in_transformers_1.pick)(['a', 'c']);
+            expect(fn({ a: 1, b: 2, c: 3 })).toEqual({ a: 1, c: 3 });
+        });
+        it('handles missing keys', () => {
+            expect((0, built_in_transformers_1.pick)(['x'])({})).toEqual({});
+        });
+    });
+    describe('omit', () => {
+        it('omits specified keys', () => {
+            const fn = (0, built_in_transformers_1.omit)(['b']);
+            expect(fn({ a: 1, b: 2, c: 3 })).toEqual({ a: 1, c: 3 });
+        });
+    });
+    describe('renameKeys', () => {
+        it('renames keys', () => {
+            const fn = (0, built_in_transformers_1.renameKeys)({ oldName: 'newName' });
+            expect(fn({ oldName: 'value', keep: 1 })).toEqual({ newName: 'value', keep: 1 });
+        });
+    });
+});

package/dist/transformers/transformer.service.js

@@ -61,5 +61,5 @@ let TransformerService = class TransformerService {
 };
 exports.TransformerService = TransformerService;
 exports.TransformerService = TransformerService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], TransformerService);

package/dist/transformers/transformer.service.test.d.ts

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

package/dist/transformers/transformer.service.test.d.ts.map

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

package/dist/transformers/transformer.service.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const transformer_service_1 = require("./transformer.service");
+describe('TransformerService', () => {
+    let service;
+    beforeEach(() => {
+        service = new transformer_service_1.TransformerService();
+    });
+    it('registers and applies transform', async () => {
+        service.register('double', (x) => x * 2);
+        const result = await service.apply('double', 5);
+        expect(result).toBe(10);
+    });
+    it('throws for unregistered transform', async () => {
+        await expect(service.apply('missing', 1)).rejects.toThrow('Transform not found: missing');
+    });
+    it('pipe composes functions', async () => {
+        const fn = service.pipe((x) => x + 1, (x) => x * 2);
+        const result = await fn(5);
+        expect(result).toBe(12);
+    });
+    it('map transforms array', async () => {
+        const mapper = service.map((x) => x * 2);
+        const result = await mapper([1, 2, 3]);
+        expect(result).toEqual([2, 4, 6]);
+    });
+    it('filter filters array', async () => {
+        const filter = service.filter((x) => x > 2);
+        const result = await filter([1, 2, 3, 4]);
+        expect(result).toEqual([3, 4]);
+    });
+});

package/dist/validators/schema.validator.js

@@ -36,5 +36,5 @@ let SchemaValidator = class SchemaValidator {
 };
 exports.SchemaValidator = SchemaValidator;
 exports.SchemaValidator = SchemaValidator = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], SchemaValidator);

package/dist/validators/schema.validator.test.d.ts

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

package/dist/validators/schema.validator.test.d.ts.map

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

package/dist/validators/schema.validator.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_validator_1 = require("./schema.validator");
+const schema_1 = require("../schema/schema");
+describe('SchemaValidator', () => {
+    let validator;
+    beforeEach(() => {
+        validator = new schema_validator_1.SchemaValidator();
+    });
+    it('validates and returns data', () => {
+        const schema = schema_1.Schema.object({ x: schema_1.Schema.number() });
+        const result = validator.validate(schema, { x: 42 });
+        expect(result).toEqual({ x: 42 });
+    });
+    it('throws SchemaValidationException on invalid data', () => {
+        const schema = schema_1.Schema.object({ x: schema_1.Schema.number() });
+        expect(() => validator.validate(schema, { x: 'not a number' })).toThrow(schema_validator_1.SchemaValidationException);
+        try {
+            validator.validate(schema, { x: 'bad' });
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(schema_validator_1.SchemaValidationException);
+            expect(e.errors).toBeDefined();
+        }
+    });
+    it('validateOrThrow is alias for validate', () => {
+        const schema = schema_1.Schema.object({ x: schema_1.Schema.number() });
+        const result = validator.validateOrThrow(schema, { x: 1 });
+        expect(result).toEqual({ x: 1 });
+    });
+    it('safeValidate returns result without throwing', () => {
+        const schema = schema_1.Schema.string();
+        const valid = validator.safeValidate(schema, 'ok');
+        expect(valid.success).toBe(true);
+        if (valid.success)
+            expect(valid.data).toBe('ok');
+        const invalid = validator.safeValidate(schema, 123);
+        expect(invalid.success).toBe(false);
+        if (!invalid.success)
+            expect(invalid.errors.length).toBeGreaterThan(0);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/data",
-  "version": "0.2.0-beta.53",
+  "version": "0.2.0-beta.55",
   "description": "Data Processing & ETL for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,5 +49,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.com",
-  "gitHead": "84311f65083627fa53bf2a22f96cd212c196873c"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }