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

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

@@ -14,11 +14,17 @@ describe('built-in transformers', () => {
         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', () => {
@@ -41,17 +47,39 @@ describe('built-in transformers', () => {
         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.test.js

@@ -29,4 +29,14 @@ describe('TransformerService', () => {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/data",
-  "version": "0.2.0-beta.67",
+  "version": "0.2.0-beta.69",
   "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": "603737b007ed113585dcd2888e36c3bb1296c7bd"
+  "gitHead": "a0aa75c1e4607c4e362f907163d248066d567517"
 }