@hazeljs/data 0.2.0-alpha.1

package/dist/testing/schema-faker.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaFaker = void 0;
+/**
+ * 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 }
+ */
+class SchemaFaker {
+    constructor(options = {}) {
+        this.options = { arrayMinLength: 1, arrayMaxLength: 5, ...options };
+    }
+    /**
+     * Generate one fake record matching the schema.
+     */
+    generate(schema) {
+        const js = schema.toJsonSchema();
+        return this.generateFromJsonSchema(js);
+    }
+    /**
+     * Generate N fake records.
+     */
+    generateMany(schema, count) {
+        return Array.from({ length: count }, () => this.generate(schema));
+    }
+    generateFromJsonSchema(js) {
+        if (js.const !== undefined)
+            return js.const;
+        if (js.oneOf) {
+            const schemas = js.oneOf;
+            const idx = Math.floor(Math.random() * schemas.length);
+            return this.generateFromJsonSchema(schemas[idx]);
+        }
+        if (js.properties) {
+            const out = {};
+            const props = js.properties;
+            for (const [k, v] of Object.entries(props)) {
+                out[k] = this.generateFromJsonSchema(v);
+            }
+            return out;
+        }
+        if (js.items) {
+            const len = Math.floor(Math.random() * (this.options.arrayMaxLength - this.options.arrayMinLength + 1)) + this.options.arrayMinLength;
+            const itemSchema = js.items;
+            return Array.from({ length: len }, () => this.generateFromJsonSchema(itemSchema));
+        }
+        const type = js.type;
+        if (Array.isArray(type)) {
+            const t = type.find((x) => x !== 'null') ?? 'string';
+            return this.genByType(t, js);
+        }
+        if (typeof type === 'string') {
+            return this.genByType(type, js);
+        }
+        return null;
+    }
+    genByType(type, _js) {
+        switch (type) {
+            case 'string':
+                return this.randomString();
+            case 'number':
+            case 'integer':
+                return Math.floor(Math.random() * 1000) - 100;
+            case 'boolean':
+                return Math.random() > 0.5;
+            case 'object':
+                return {};
+            case 'array':
+                return [];
+            default:
+                return null;
+        }
+    }
+    randomString() {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        const len = Math.floor(Math.random() * 10) + 5;
+        return Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+    }
+    /** Static convenience method */
+    static generate(schema) {
+        return new SchemaFaker().generate(schema);
+    }
+    static generateMany(schema, count) {
+        return new SchemaFaker().generateMany(schema, count);
+    }
+}
+exports.SchemaFaker = SchemaFaker;

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

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

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

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

package/dist/testing/schema-faker.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("../schema/schema");
+const schema_faker_1 = require("./schema-faker");
+describe('SchemaFaker', () => {
+    it('generates string', () => {
+        const schema = schema_1.Schema.string();
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(typeof value).toBe('string');
+        expect(schema.validate(value).success).toBe(true);
+    });
+    it('generates number', () => {
+        const schema = schema_1.Schema.number();
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(typeof value).toBe('number');
+        expect(schema.validate(value).success).toBe(true);
+    });
+    it('generates boolean', () => {
+        const schema = schema_1.Schema.boolean();
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(typeof value).toBe('boolean');
+        expect(schema.validate(value).success).toBe(true);
+    });
+    it('generates object', () => {
+        const schema = schema_1.Schema.object({ name: schema_1.Schema.string(), age: schema_1.Schema.number() });
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(value).toHaveProperty('name');
+        expect(value).toHaveProperty('age');
+        expect(schema.validate(value).success).toBe(true);
+    });
+    it('generateMany returns array', () => {
+        const schema = schema_1.Schema.object({ id: schema_1.Schema.number() });
+        const values = schema_faker_1.SchemaFaker.generateMany(schema, 3);
+        expect(values).toHaveLength(3);
+        values.forEach((v) => expect(schema.validate(v).success).toBe(true));
+    });
+    it('generates literal', () => {
+        const schema = schema_1.Schema.literal('active');
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(value).toBe('active');
+    });
+    it('generates array', () => {
+        const schema = schema_1.Schema.array(schema_1.Schema.number());
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(Array.isArray(value)).toBe(true);
+        expect(schema.validate(value).success).toBe(true);
+    });
+    it('generates union', () => {
+        const schema = schema_1.Schema.union([schema_1.Schema.literal('a'), schema_1.Schema.literal('b')]);
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(['a', 'b']).toContain(value);
+    });
+    it('constructor with custom array length options', () => {
+        const faker = new schema_faker_1.SchemaFaker({ arrayMinLength: 2, arrayMaxLength: 4 });
+        const schema = schema_1.Schema.array(schema_1.Schema.number());
+        const value = faker.generate(schema);
+        expect(Array.isArray(value)).toBe(true);
+        expect(value.length).toBeGreaterThanOrEqual(2);
+        expect(value.length).toBeLessThanOrEqual(4);
+    });
+    it('generateFromJsonSchema handles nullable type array', () => {
+        const schema = schema_1.Schema.string().nullable();
+        const value = schema_faker_1.SchemaFaker.generate(schema);
+        expect(value === null || typeof value === 'string').toBe(true);
+    });
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Built-in transformers for common data operations
+ */
+export declare const trimString: (value: unknown) => string;
+export declare const toLowerCase: (value: unknown) => string;
+export declare const toUpperCase: (value: unknown) => string;
+export declare const parseJson: (value: unknown) => unknown;
+export declare const stringifyJson: (value: unknown) => string;
+export declare const pick: (keys: string[]) => (obj: unknown) => Record<string, unknown>;
+export declare const omit: (keys: string[]) => (obj: unknown) => Record<string, unknown>;
+export declare const renameKeys: (mapping: Record<string, string>) => (obj: unknown) => Record<string, unknown>;
+//# sourceMappingURL=built-in.transformers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"built-in.transformers.d.ts","sourceRoot":"","sources":["../../src/transformers/built-in.transformers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,MAG3C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,MAG5C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,MAG5C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,OAK1C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,MAE9C,CAAC;AAEF,eAAO,MAAM,IAAI,GACd,MAAM,MAAM,EAAE,MACd,KAAK,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAQrC,CAAC;AAEJ,eAAO,MAAM,IAAI,GACd,MAAM,MAAM,EAAE,MACd,KAAK,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAQrC,CAAC;AAEJ,eAAO,MAAM,UAAU,GACpB,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAC/B,KAAK,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAWrC,CAAC"}

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

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Built-in transformers for common data operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameKeys = exports.omit = exports.pick = exports.stringifyJson = exports.parseJson = exports.toUpperCase = exports.toLowerCase = exports.trimString = void 0;
+const trimString = (value) => {
+    if (typeof value !== 'string')
+        return String(value);
+    return value.trim();
+};
+exports.trimString = trimString;
+const toLowerCase = (value) => {
+    if (typeof value !== 'string')
+        return String(value).toLowerCase();
+    return value.toLowerCase();
+};
+exports.toLowerCase = toLowerCase;
+const toUpperCase = (value) => {
+    if (typeof value !== 'string')
+        return String(value).toUpperCase();
+    return value.toUpperCase();
+};
+exports.toUpperCase = toUpperCase;
+const parseJson = (value) => {
+    if (typeof value === 'string') {
+        return JSON.parse(value);
+    }
+    return value;
+};
+exports.parseJson = parseJson;
+const stringifyJson = (value) => {
+    return JSON.stringify(value);
+};
+exports.stringifyJson = stringifyJson;
+const pick = (keys) => (obj) => {
+    if (obj === null || typeof obj !== 'object')
+        return {};
+    const result = {};
+    const source = obj;
+    for (const key of keys) {
+        if (key in source)
+            result[key] = source[key];
+    }
+    return result;
+};
+exports.pick = pick;
+const omit = (keys) => (obj) => {
+    if (obj === null || typeof obj !== 'object')
+        return {};
+    const result = {};
+    const source = obj;
+    for (const key of Object.keys(source)) {
+        if (!keys.includes(key))
+            result[key] = source[key];
+    }
+    return result;
+};
+exports.omit = omit;
+const renameKeys = (mapping) => (obj) => {
+    if (obj === null || typeof obj !== 'object')
+        return {};
+    const result = {};
+    const source = obj;
+    for (const [oldKey, newKey] of Object.entries(mapping)) {
+        if (oldKey in source)
+            result[newKey] = source[oldKey];
+    }
+    for (const [key, value] of Object.entries(source)) {
+        if (!(key in mapping))
+            result[key] = value;
+    }
+    return result;
+};
+exports.renameKeys = renameKeys;

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,85 @@
+"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');
+        });
+        it('converts non-string', () => {
+            expect((0, built_in_transformers_1.toLowerCase)(123)).toBe('123');
+        });
+    });
+    describe('toUpperCase', () => {
+        it('uppercases string', () => {
+            expect((0, built_in_transformers_1.toUpperCase)('hello')).toBe('HELLO');
+        });
+        it('converts non-string', () => {
+            expect((0, built_in_transformers_1.toUpperCase)(123)).toBe('123');
+        });
+    });
+    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({});
+        });
+        it('returns empty for null', () => {
+            expect((0, built_in_transformers_1.pick)(['a'])(null)).toEqual({});
+        });
+        it('returns empty for non-object', () => {
+            expect((0, built_in_transformers_1.pick)(['a'])('string')).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 });
+        });
+        it('returns empty for null', () => {
+            expect((0, built_in_transformers_1.omit)(['a'])(null)).toEqual({});
+        });
+        it('returns empty for non-object', () => {
+            expect((0, built_in_transformers_1.omit)(['a'])(123)).toEqual({});
+        });
+    });
+    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 });
+        });
+        it('returns empty for null', () => {
+            expect((0, built_in_transformers_1.renameKeys)({ a: 'b' })(null)).toEqual({});
+        });
+        it('returns empty for non-object', () => {
+            expect((0, built_in_transformers_1.renameKeys)({ a: 'b' })(123)).toEqual({});
+        });
+        it('keeps keys not in mapping', () => {
+            const fn = (0, built_in_transformers_1.renameKeys)({ a: 'A' });
+            expect(fn({ a: 1, b: 2 })).toEqual({ A: 1, b: 2 });
+        });
+    });
+});

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

@@ -0,0 +1,14 @@
+export type TransformFn<T = unknown, R = unknown> = (input: T) => R | Promise<R>;
+/**
+ * Transformer Service - Data transformations
+ * Provides utilities for common data transformation patterns
+ */
+export declare class TransformerService {
+    private transforms;
+    register(name: string, fn: TransformFn): void;
+    apply<T, R>(name: string, input: T): Promise<R>;
+    pipe<T>(...fns: Array<(x: unknown) => unknown | Promise<unknown>>): (input: T) => Promise<unknown>;
+    map<T, R>(fn: (item: T) => R | Promise<R>): (items: T[]) => Promise<R[]>;
+    filter<T>(predicate: (item: T) => boolean | Promise<boolean>): (items: T[]) => Promise<T[]>;
+}
+//# sourceMappingURL=transformer.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.service.d.ts","sourceRoot":"","sources":["../../src/transformers/transformer.service.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAEjF;;;GAGG;AACH,qBACa,kBAAkB;IAC7B,OAAO,CAAC,UAAU,CAAuC;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI;IAKvC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IASrD,IAAI,CAAC,CAAC,EACJ,GAAG,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GACxD,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC;IAWjC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;IAMxE,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC;CAU5F"}

package/dist/transformers/transformer.service.js

@@ -0,0 +1,65 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformerService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Transformer Service - Data transformations
+ * Provides utilities for common data transformation patterns
+ */
+let TransformerService = class TransformerService {
+    constructor() {
+        this.transforms = new Map();
+    }
+    register(name, fn) {
+        this.transforms.set(name, fn);
+        core_2.default.debug(`Registered transform: ${name}`);
+    }
+    async apply(name, input) {
+        const fn = this.transforms.get(name);
+        if (!fn) {
+            throw new Error(`Transform not found: ${name}`);
+        }
+        const result = fn(input);
+        return (result instanceof Promise ? await result : result);
+    }
+    pipe(...fns) {
+        return async (input) => {
+            let data = input;
+            for (const fn of fns) {
+                const result = fn(data);
+                data = result instanceof Promise ? await result : result;
+            }
+            return data;
+        };
+    }
+    map(fn) {
+        return async (items) => {
+            return Promise.all(items.map((item) => Promise.resolve(fn(item))));
+        };
+    }
+    filter(predicate) {
+        return async (items) => {
+            const results = [];
+            for (const item of items) {
+                const keep = await Promise.resolve(predicate(item));
+                if (keep)
+                    results.push(item);
+            }
+            return results;
+        };
+    }
+};
+exports.TransformerService = TransformerService;
+exports.TransformerService = TransformerService = __decorate([
+    (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,42 @@
+"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]);
+    });
+    it('apply returns sync result without awaiting', async () => {
+        service.register('sync', (x) => x + 1);
+        const result = await service.apply('sync', 10);
+        expect(result).toBe(11);
+    });
+    it('filter with async predicate', async () => {
+        const filter = service.filter(async (x) => x > 1);
+        const result = await filter([1, 2, 3]);
+        expect(result).toEqual([2, 3]);
+    });
+});

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

@@ -0,0 +1,21 @@
+import type { BaseSchema } from '../schema/schema';
+import type { SchemaValidationError } from '../schema/schema';
+export declare class SchemaValidationException extends Error {
+    readonly errors: SchemaValidationError[];
+    constructor(message: string, errors: SchemaValidationError[]);
+}
+/**
+ * Schema Validator - Validates data against schemas
+ */
+export declare class SchemaValidator {
+    validate<T>(schema: BaseSchema<T>, value: unknown): T;
+    validateOrThrow<T>(schema: BaseSchema<T>, value: unknown): T;
+    safeValidate<T>(schema: BaseSchema<T>, value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        errors: SchemaValidationError[];
+    };
+}
+//# sourceMappingURL=schema.validator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.validator.d.ts","sourceRoot":"","sources":["../../src/validators/schema.validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,qBAAa,yBAA0B,SAAQ,KAAK;aAGhC,MAAM,EAAE,qBAAqB,EAAE;gBAD/C,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,qBAAqB,EAAE;CAKlD;AAED;;GAEG;AACH,qBACa,eAAe;IAC1B,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC;IAWrD,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC;IAI5D,YAAY,CAAC,CAAC,EACZ,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,OAAO,GACb;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,CAAC,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,qBAAqB,EAAE,CAAA;KAAE;CAKpF"}

package/dist/validators/schema.validator.js

@@ -0,0 +1,40 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidator = exports.SchemaValidationException = void 0;
+const core_1 = require("@hazeljs/core");
+class SchemaValidationException extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = 'SchemaValidationException';
+    }
+}
+exports.SchemaValidationException = SchemaValidationException;
+/**
+ * Schema Validator - Validates data against schemas
+ */
+let SchemaValidator = class SchemaValidator {
+    validate(schema, value) {
+        const result = schema.validate(value);
+        if (result.success) {
+            return result.data;
+        }
+        throw new SchemaValidationException(`Validation failed: ${result.errors.map((e) => `${e.path}: ${e.message}`).join('; ')}`, result.errors);
+    }
+    validateOrThrow(schema, value) {
+        return this.validate(schema, value);
+    }
+    safeValidate(schema, value) {
+        return schema.validate(value);
+    }
+};
+exports.SchemaValidator = SchemaValidator;
+exports.SchemaValidator = SchemaValidator = __decorate([
+    (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

@@ -0,0 +1,53 @@
+{
+  "name": "@hazeljs/data",
+  "version": "0.2.0-alpha.1",
+  "description": "Data Processing & ETL for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --skipLibCheck",
+    "test": "jest --coverage --maxWorkers=1",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/data"
+  },
+  "keywords": [
+    "hazeljs",
+    "data",
+    "etl",
+    "pipeline",
+    "flink",
+    "streaming",
+    "validation"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}