@hazeljs/data 0.2.0-alpha.1

package/dist/schema/schema.js

@@ -0,0 +1,487 @@
+"use strict";
+/**
+ * Schema builder for data validation - fluent API
+ * Zero runtime dependencies. TypeScript-first with full type inference.
+ *
+ * Supported types: string, number, boolean, date, object, array, literal, union
+ * Modifiers: optional, nullable, default, transform, refine, refineAsync
+ * Utilities: toJsonSchema(), Infer<T>, validateAsync()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+// ─── Core buildSchema helper ──────────────────────────────────────────────────
+function buildSchema(syncValidate, jsonSchemaFn, refinements = [], asyncRefinements = []) {
+    const validate = (value) => {
+        const result = syncValidate(value);
+        if (!result.success)
+            return result;
+        for (const r of refinements) {
+            if (!r.fn(result.data)) {
+                return { success: false, errors: [{ path: '', message: r.message }] };
+            }
+        }
+        return result;
+    };
+    return {
+        _type: undefined,
+        validate,
+        async validateAsync(value) {
+            const result = validate(value);
+            if (!result.success)
+                return result;
+            for (const r of asyncRefinements) {
+                const ok = await r.fn(result.data);
+                if (!ok) {
+                    return { success: false, errors: [{ path: '', message: r.message }] };
+                }
+            }
+            return result;
+        },
+        optional() {
+            return buildSchema((v) => v === undefined
+                ? { success: true, data: undefined }
+                : validate(v), () => {
+                const js = jsonSchemaFn();
+                return { ...js, _optional: true };
+            });
+        },
+        nullable() {
+            return buildSchema((v) => (v === null ? { success: true, data: null } : validate(v)), () => {
+                const js = jsonSchemaFn();
+                const t = js['type'];
+                return { ...js, type: t ? [t, 'null'] : ['null'] };
+            });
+        },
+        default(defaultValue) {
+            return buildSchema((v) => (v === undefined ? { success: true, data: defaultValue } : validate(v)), () => ({ ...jsonSchemaFn(), default: defaultValue }));
+        },
+        transform(fn) {
+            return buildSchema((v) => {
+                const result = validate(v);
+                if (!result.success)
+                    return result;
+                try {
+                    return { success: true, data: fn(result.data) };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        errors: [{ path: '', message: e instanceof Error ? e.message : 'Transform failed' }],
+                    };
+                }
+            }, jsonSchemaFn);
+        },
+        refine(fn, message) {
+            return buildSchema(syncValidate, jsonSchemaFn, [...refinements, { fn, message }], asyncRefinements);
+        },
+        refineAsync(fn, message) {
+            return buildSchema(syncValidate, jsonSchemaFn, refinements, [
+                ...asyncRefinements,
+                { fn, message },
+            ]);
+        },
+        toJsonSchema() {
+            return jsonSchemaFn();
+        },
+    };
+}
+// ─── String Schema Factory ────────────────────────────────────────────────────
+function createStringSchema(constraints = [], preprocessors = [], refinements = [], asyncRefinements = []) {
+    const syncValidate = (value) => {
+        if (typeof value !== 'string') {
+            return { success: false, errors: [{ path: '', message: 'Expected string' }] };
+        }
+        let v = value;
+        for (const pre of preprocessors)
+            v = pre(v);
+        for (const c of constraints) {
+            const err = c(v);
+            if (err)
+                return { success: false, errors: [{ path: '', message: err }] };
+        }
+        return { success: true, data: v };
+    };
+    const jsonSchemaFn = () => ({ type: 'string' });
+    const base = buildSchema(syncValidate, jsonSchemaFn, refinements, asyncRefinements);
+    const addConstraint = (c) => createStringSchema([...constraints, c], preprocessors, refinements, asyncRefinements);
+    const schema = {
+        ...base,
+        email() {
+            return addConstraint((v) => {
+                const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                return re.test(v) ? null : 'Invalid email';
+            });
+        },
+        url() {
+            return addConstraint((v) => {
+                try {
+                    new URL(v);
+                    return null;
+                }
+                catch {
+                    return 'Invalid URL';
+                }
+            });
+        },
+        min(length) {
+            return addConstraint((v) => (v.length >= length ? null : `Min length ${length}`));
+        },
+        max(length) {
+            return addConstraint((v) => (v.length <= length ? null : `Max length ${length}`));
+        },
+        uuid() {
+            return addConstraint((v) => {
+                const re = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+                return re.test(v) ? null : 'Invalid UUID';
+            });
+        },
+        oneOf(values) {
+            return addConstraint((v) => values.includes(v) ? null : `Must be one of: ${values.join(', ')}`);
+        },
+        pattern(regex, message = 'Invalid format') {
+            return addConstraint((v) => (regex.test(v) ? null : message));
+        },
+        required() {
+            return addConstraint((v) => (v.length > 0 ? null : 'Value is required'));
+        },
+        trim() {
+            return createStringSchema(constraints, [...preprocessors, (v) => v.trim()], refinements, asyncRefinements);
+        },
+        refine(fn, message) {
+            return createStringSchema(constraints, preprocessors, [...refinements, { fn, message }], asyncRefinements);
+        },
+        refineAsync(fn, message) {
+            return createStringSchema(constraints, preprocessors, refinements, [
+                ...asyncRefinements,
+                { fn, message },
+            ]);
+        },
+        default(value) {
+            const next = createStringSchema(constraints, preprocessors, refinements, asyncRefinements);
+            const originalValidate = next.validate.bind(next);
+            return {
+                ...next,
+                validate: (v) => v === undefined ? { success: true, data: value } : originalValidate(v),
+                toJsonSchema: () => ({ type: 'string', default: value }),
+            };
+        },
+        toJsonSchema() {
+            return { type: 'string' };
+        },
+    };
+    return schema;
+}
+// ─── Number Schema Factory ────────────────────────────────────────────────────
+function createNumberSchema(constraints = [], refinements = [], asyncRefinements = []) {
+    const syncValidate = (value) => {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+            return { success: false, errors: [{ path: '', message: 'Expected number' }] };
+        }
+        for (const c of constraints) {
+            const err = c(value);
+            if (err)
+                return { success: false, errors: [{ path: '', message: err }] };
+        }
+        return { success: true, data: value };
+    };
+    const jsonSchemaFn = () => ({ type: 'number' });
+    const base = buildSchema(syncValidate, jsonSchemaFn, refinements, asyncRefinements);
+    const addConstraint = (c) => createNumberSchema([...constraints, c], refinements, asyncRefinements);
+    const schema = {
+        ...base,
+        min(n) {
+            return addConstraint((v) => (v >= n ? null : `Min ${n}`));
+        },
+        max(n) {
+            return addConstraint((v) => (v <= n ? null : `Max ${n}`));
+        },
+        integer() {
+            return addConstraint((v) => (Number.isInteger(v) ? null : 'Must be an integer'));
+        },
+        positive() {
+            return addConstraint((v) => (v > 0 ? null : 'Must be positive'));
+        },
+        negative() {
+            return addConstraint((v) => (v < 0 ? null : 'Must be negative'));
+        },
+        multipleOf(n) {
+            return addConstraint((v) => (v % n === 0 ? null : `Must be a multiple of ${n}`));
+        },
+        refine(fn, message) {
+            return createNumberSchema(constraints, [...refinements, { fn, message }], asyncRefinements);
+        },
+        refineAsync(fn, message) {
+            return createNumberSchema(constraints, refinements, [...asyncRefinements, { fn, message }]);
+        },
+        default(value) {
+            const next = createNumberSchema(constraints, refinements, asyncRefinements);
+            const originalValidate = next.validate.bind(next);
+            return {
+                ...next,
+                validate: (v) => v === undefined ? { success: true, data: value } : originalValidate(v),
+                toJsonSchema: () => ({ type: 'number', default: value }),
+            };
+        },
+        toJsonSchema() {
+            return { type: 'number' };
+        },
+    };
+    return schema;
+}
+// ─── Boolean Schema Factory ───────────────────────────────────────────────────
+function createBooleanSchema() {
+    const syncValidate = (value) => {
+        if (typeof value !== 'boolean') {
+            return { success: false, errors: [{ path: '', message: 'Expected boolean' }] };
+        }
+        return { success: true, data: value };
+    };
+    const base = buildSchema(syncValidate, () => ({ type: 'boolean' }));
+    return {
+        ...base,
+        default(value) {
+            return {
+                ...createBooleanSchema(),
+                validate: (v) => v === undefined ? { success: true, data: value } : syncValidate(v),
+                toJsonSchema: () => ({ type: 'boolean', default: value }),
+            };
+        },
+        toJsonSchema() {
+            return { type: 'boolean' };
+        },
+    };
+}
+// ─── Date Schema Factory ──────────────────────────────────────────────────────
+function createDateSchema(constraints = []) {
+    const syncValidate = (value) => {
+        let date;
+        if (value instanceof Date && !Number.isNaN(value.getTime())) {
+            date = value;
+        }
+        else if (typeof value === 'string' || typeof value === 'number') {
+            const d = new Date(value);
+            if (Number.isNaN(d.getTime())) {
+                return { success: false, errors: [{ path: '', message: 'Expected date' }] };
+            }
+            date = d;
+        }
+        else {
+            return { success: false, errors: [{ path: '', message: 'Expected date' }] };
+        }
+        for (const c of constraints) {
+            const err = c(date);
+            if (err)
+                return { success: false, errors: [{ path: '', message: err }] };
+        }
+        return { success: true, data: date };
+    };
+    const base = buildSchema(syncValidate, () => ({ type: 'string', format: 'date-time' }));
+    const addConstraint = (c) => createDateSchema([...constraints, c]);
+    return {
+        ...base,
+        min(date) {
+            return addConstraint((v) => (v >= date ? null : `Date must be after ${date.toISOString()}`));
+        },
+        max(date) {
+            return addConstraint((v) => (v <= date ? null : `Date must be before ${date.toISOString()}`));
+        },
+        default(value) {
+            const next = createDateSchema(constraints);
+            const originalValidate = next.validate.bind(next);
+            return {
+                ...next,
+                validate: (v) => v === undefined ? { success: true, data: value } : originalValidate(v),
+                toJsonSchema: () => ({ type: 'string', format: 'date-time', default: value.toISOString() }),
+            };
+        },
+        toJsonSchema() {
+            return { type: 'string', format: 'date-time' };
+        },
+    };
+}
+function createObjectSchema(shape, strictMode = false) {
+    const syncValidate = (value) => {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            return { success: false, errors: [{ path: '', message: 'Expected object' }] };
+        }
+        const obj = value;
+        if (strictMode) {
+            const extraKeys = Object.keys(obj).filter((k) => !(k in shape));
+            if (extraKeys.length > 0) {
+                return {
+                    success: false,
+                    errors: [{ path: '', message: `Unknown keys: ${extraKeys.join(', ')}` }],
+                };
+            }
+        }
+        const data = {};
+        const errors = [];
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            const result = fieldSchema.validate(obj[key]);
+            if (result.success) {
+                data[key] = result.data;
+            }
+            else {
+                errors.push(...result.errors.map((e) => ({
+                    path: key + (e.path ? '.' + e.path : ''),
+                    message: e.message,
+                })));
+            }
+        }
+        if (errors.length > 0)
+            return { success: false, errors };
+        return { success: true, data: data };
+    };
+    const jsonSchemaFn = () => ({
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(shape).map(([k, s]) => [k, s.toJsonSchema()])),
+        required: Object.keys(shape),
+        additionalProperties: !strictMode,
+    });
+    const base = buildSchema(syncValidate, jsonSchemaFn);
+    const objSchema = {
+        ...base,
+        shape: shape,
+        strict() {
+            return createObjectSchema(shape, true);
+        },
+        pick(keys) {
+            const pickedShape = Object.fromEntries(keys.filter((k) => k in shape).map((k) => [k, shape[k]]));
+            return createObjectSchema(pickedShape);
+        },
+        omit(keys) {
+            const omittedShape = Object.fromEntries(Object.entries(shape).filter(([k]) => !keys.includes(k)));
+            return createObjectSchema(omittedShape);
+        },
+        extend(extra) {
+            return createObjectSchema({ ...shape, ...extra });
+        },
+        toJsonSchema() {
+            return jsonSchemaFn();
+        },
+    };
+    return objSchema;
+}
+// ─── Array Schema Factory ─────────────────────────────────────────────────────
+function createArraySchema(itemSchema, constraints = []) {
+    const syncValidate = (value) => {
+        if (!Array.isArray(value)) {
+            return { success: false, errors: [{ path: '', message: 'Expected array' }] };
+        }
+        const data = [];
+        const errors = [];
+        for (let i = 0; i < value.length; i++) {
+            const result = itemSchema.validate(value[i]);
+            if (result.success) {
+                data.push(result.data);
+            }
+            else {
+                errors.push(...result.errors.map((e) => ({
+                    path: `[${i}]${e.path ? '.' + e.path : ''}`,
+                    message: e.message,
+                })));
+            }
+        }
+        if (errors.length > 0)
+            return { success: false, errors };
+        for (const c of constraints) {
+            const err = c(data);
+            if (err)
+                return { success: false, errors: [{ path: '', message: err }] };
+        }
+        return { success: true, data };
+    };
+    const jsonSchemaFn = () => ({
+        type: 'array',
+        items: itemSchema.toJsonSchema(),
+    });
+    const base = buildSchema(syncValidate, jsonSchemaFn);
+    const addConstraint = (c) => createArraySchema(itemSchema, [...constraints, c]);
+    return {
+        ...base,
+        min(length) {
+            return addConstraint((v) => v.length >= length ? null : `Array must have at least ${length} items`);
+        },
+        max(length) {
+            return addConstraint((v) => v.length <= length ? null : `Array must have at most ${length} items`);
+        },
+        nonempty() {
+            return addConstraint((v) => (v.length > 0 ? null : 'Array must not be empty'));
+        },
+        toJsonSchema() {
+            return jsonSchemaFn();
+        },
+    };
+}
+// ─── Literal Schema Factory ───────────────────────────────────────────────────
+function createLiteralSchema(literalValue) {
+    const syncValidate = (value) => {
+        if (value !== literalValue) {
+            return {
+                success: false,
+                errors: [{ path: '', message: `Expected literal ${JSON.stringify(literalValue)}` }],
+            };
+        }
+        return { success: true, data: value };
+    };
+    const base = buildSchema(syncValidate, () => ({ const: literalValue }));
+    return {
+        ...base,
+        value: literalValue,
+        toJsonSchema() {
+            return { const: literalValue };
+        },
+    };
+}
+// ─── Union Schema Factory ─────────────────────────────────────────────────────
+function createUnionSchema(schemas) {
+    const syncValidate = (value) => {
+        const allErrors = [];
+        for (const s of schemas) {
+            const result = s.validate(value);
+            if (result.success)
+                return { success: true, data: result.data };
+            allErrors.push(...result.errors);
+        }
+        return {
+            success: false,
+            errors: [{ path: '', message: 'Value did not match any schema in union' }],
+        };
+    };
+    const base = buildSchema(syncValidate, () => ({
+        oneOf: schemas.map((s) => s.toJsonSchema()),
+    }));
+    return {
+        ...base,
+        toJsonSchema() {
+            return { oneOf: schemas.map((s) => s.toJsonSchema()) };
+        },
+    };
+}
+// ─── Schema Namespace ─────────────────────────────────────────────────────────
+exports.Schema = {
+    string() {
+        return createStringSchema();
+    },
+    number() {
+        return createNumberSchema();
+    },
+    boolean() {
+        return createBooleanSchema();
+    },
+    date() {
+        return createDateSchema();
+    },
+    object(shape) {
+        return createObjectSchema(shape);
+    },
+    array(itemSchema) {
+        return createArraySchema(itemSchema);
+    },
+    literal(value) {
+        return createLiteralSchema(value);
+    },
+    union(schemas) {
+        return createUnionSchema(schemas);
+    },
+};

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":""}