@adobe/data 0.2.1 → 0.2.2

package/src/schema/schema.ts

@@ -1,229 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-
-import { DeepReadonly, EquivalentTypes, True } from "../types/types.js";
-
-type JSONPath = string;
-type JSONMergePatch = unknown;
-
-/**
- * Conditional patch applied to the path when the enclosing schema branch is active
- * and `match` is not present or validates against the root.
- * This is used for dynamic schemas which change in response to the value of the data.
- */
-export type Conditional = {
-  match?: Schema;
-  // // root-anchored JSONPath
-  path: JSONPath;
-  // // JSON-Merge-Patch fragment
-  value: JSONMergePatch;
-}
-
-export interface UIProperties {
-  name?: string;
-  icon?: string; // url? or icon name?
-  summary?: string;
-  premium?: boolean;
-  placeholder?: string;
-  details?: string;
-  visible?: boolean;
-  enabled?: boolean;
-  infoUrl?: string;
-  group?: string;
-  order?: number;
-  groups?: {
-    readonly [key: string]: UIProperties;
-  };
-}
-
-export interface Schema {
-  type?: 'number' | 'integer' | 'string' | 'boolean' | 'null' | 'array' | 'object';
-  conditionals?: readonly Conditional[];
-  ui?: UIProperties;
-  default?: any;
-  precision?: 1 | 2;
-  multipleOf?: number;
-  mediaType?: string; // media type such as image/jpeg, image/png, video/* etc.
-  minimum?: number;
-  maximum?: number;
-  minLength?: number;
-  maxLength?: number;
-  exclusiveMinimum?: number;
-  exclusiveMaximum?: number;
-  pattern?: string;
-  minItems?: number;
-  maxItems?: number;
-  items?: Schema;
-  properties?: { readonly [key: string]: Schema };
-  required?: readonly string[];
-  additionalProperties?: boolean | Schema;
-  oneOf?: readonly Schema[];
-  const?: any;
-  enum?: readonly any[];
-}
-
-export type FromSchema<T, Depth extends number = 5> = DeepReadonly<Depth extends 0
-  ? any
-  : T extends { const: infer Const }
-  ? Const
-  : T extends { enum: infer Enum }
-  ? Enum extends ReadonlyArray<any> ? Enum[number] : never
-  : T extends { oneOf: infer Schemas }
-  ? Schemas extends ReadonlyArray<Schema> ? FromOneOfSchema<Schemas, Decrement<Depth>> : never
-  : T extends { type: 'number' | 'integer' }
-  ? number
-  : T extends { type: 'string' }
-  ? string
-  : T extends { type: 'boolean' }
-  ? boolean
-  : T extends { type: 'null' }
-  ? null
-  : T extends { type: 'array' } | { items: any }
-  ? FromSchemaArray<T, Decrement<Depth>>
-  : T extends { type: 'object' } | { properties: any }
-  ? FromSchemaObject<T, Decrement<Depth>>
-  : any
->;
-
-type Decrement<N extends number> = ((...x: any[]) => void) extends (
-  arg: any,
-  ...rest: infer R
-) => void
-  ? R['length']
-  : never;
-
-type FromSchemaArray<T, Depth extends number> = T extends {
-  items: infer Items;
-}
-  ? T extends { minItems: infer Min; maxItems: infer Max }
-  ? Equal<Min, Max> extends true
-  ? BuildTuple<FromSchema<Items, Depth>, Min>
-  : FromSchema<Items, Depth>[]
-  : FromSchema<Items, Depth>[]
-  : any[];
-
-type BuildTuple<T, N, R extends unknown[] = []> = R['length'] extends N
-  ? R
-  : BuildTuple<T, N, [...R, T]>;
-
-// Handle up to 16 elements
-type BuildTupleHelper<T, N> = N extends number ? BuildTuple<T, N> : T[];
-
-type FromSchemaObject<T extends Schema, Depth extends number> = T extends {
-  properties: infer P;
-}
-  ? Simplify<
-    {
-      [K in RequiredKeys<T>]: FromSchema<P[K], Depth>;
-    } & {
-      [K in OptionalKeys<T>]?: FromSchema<P[K], Depth>;
-    } & (T extends { additionalProperties: infer AP }
-      ? AP extends false
-      ? {}
-      : AP extends Schema
-      ? { [key: string]: FromSchema<AP, Depth> }
-      : { [key: string]: any }
-      : { [key: string]: any })
-  >
-  : T extends { additionalProperties: infer AP }
-  ? AP extends Schema
-  ? { [key: string]: FromSchema<AP, Depth> }
-  : { [key: string]: any }
-  : { [key: string]: any };
-
-type RequiredKeys<T> = T extends { required: infer R }
-  ? R extends readonly (infer K)[]
-  ? K extends string
-  ? K
-  : never
-  : never
-  : never;
-
-type OptionalKeys<T> = T extends { properties: infer P }
-  ? Exclude<keyof P, RequiredKeys<T>>
-  : never;
-
-type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <
-  T
->() => T extends B ? 1 : 2
-  ? true
-  : false;
-
-type Simplify<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
-
-type FromOneOfSchema<Schemas extends ReadonlyArray<Schema>, Depth extends number> = Schemas[number] extends infer S
-  ? S extends Schema
-  ? FromSchema<S, Depth>
-  : never
-  : never;
-
-//  type check tests
-
-type Test1 = FromSchema<{ type: 'number' }>; // number
-type CheckNumber = True<EquivalentTypes<Test1, number>>;
-
-type Test2 = FromSchema<{
-  properties: {
-    a: { type: 'number' };
-    b: { type: 'string' };
-  };
-  required: ['a'];
-  additionalProperties: false;
-}>; // { a: number; b?: string }
-type CheckObject = True<EquivalentTypes<Test2, { a: number; b?: string }>>;
-
-type Test3 = FromSchema<{
-  type: 'array';
-  items: { type: 'number' };
-  minItems: 3;
-  maxItems: 3;
-}>; // [number, number, number]
-type CheckTuple = True<EquivalentTypes<Test3, readonly [number, number, number]>>;
-
-type TestConst = FromSchema<{ const: 42 }>; // 42
-type CheckConst = True<EquivalentTypes<TestConst, 42>>;
-
-type TestEnum = FromSchema<{ enum: [1, 2, 3] }>; // 1 | 2 | 3
-type CheckEnum = True<EquivalentTypes<TestEnum, 1 | 2 | 3>>;
-
-type TestStringEnum = FromSchema<{ enum: ['a', 'b', 'c'] }>; // 'a' | 'b' | 'c'
-type CheckStringEnum = True<EquivalentTypes<TestStringEnum, 'a' | 'b' | 'c'>>;
-
-const mySchema = {
-  type: 'object',
-  properties: {
-    a: { type: 'number' },
-    b: { type: 'string' },
-    c: { enum: [1, 2, 3] }
-  },
-  required: ['a', 'c'],
-  additionalProperties: false,
-} as const satisfies Schema;
-
-type MyType = FromSchema<typeof mySchema>;
-type CheckMyType = True<EquivalentTypes<MyType, { a: number; b?: string; c: 1 | 2 | 3 }>>;
-
-type TestAdditionalProps = FromSchema<{
-  type: 'object';
-  additionalProperties: { type: 'number' }
-}>; // { [key: string]: number }
-type CheckTestAdditionalProps = True<EquivalentTypes<TestAdditionalProps, { readonly [x: string]: number; }>>;

package/src/schema/time.ts

@@ -1,5 +0,0 @@
-import { F32Schema } from "./f32.js";
-import { FromSchema } from "./schema.js";
-
-export const TimeSchema = F32Schema;
-export type Time = FromSchema<typeof TimeSchema>;

package/src/schema/true.ts

@@ -1,26 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { Schema } from "./schema.js";
-
-export const TrueSchema = { type: "boolean", const: true, default: true } as const satisfies Schema;
-
-export type True = true;

package/src/schema/tuple.ts

@@ -1,5 +0,0 @@
-import { Schema } from "./schema.js";
-
-export function Tuple<T extends Schema, N extends number>(items: T, length: N) {
-  return { type: "array", items, minItems: length, maxItems: length } as const satisfies Schema;
-}

package/src/schema/u32.ts

@@ -1,31 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import type { Schema } from "./schema.js";
-
-export const U32Schema = {
-    type: 'integer',
-    minimum: 0,
-    maximum: 4294967295,
-    default: 0 as number,
-} as const satisfies Schema;
-
-export type U32 = number;

package/src/schema/validation/is-valid.test.ts

@@ -1,43 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { describe, it, expect } from 'vitest';
-import { isValid } from './is-valid.js';
-import { Schema } from '../schema.js';
-
-describe('isValid', () => {
-    const schema: Schema = {
-        type: 'object',
-        properties: {
-            foo: { type: 'string' }
-        },
-        required: ['foo']
-    };
-
-    it('returns true for valid data', () => {
-        expect(isValid(schema, { foo: 'bar' })).toBe(true);
-    });
-
-    it('returns false for invalid data', () => {
-        expect(isValid(schema, { foo: 123 })).toBe(false);
-        expect(isValid(schema, {})).toBe(false);
-    });
-}); 

package/src/schema/validation/is-valid.ts

@@ -1,32 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { Schema } from "../schema.js";
-import { validate } from "./validate.js";
-
-export function isValid(schema: Schema, data: any) {
-    try {
-        return validate(schema, data ?? null).length === 0;
-    } catch (error) {
-        console.error(`Error during validation:`, error);
-        return false;
-    }
-}

package/src/schema/validation/validate.test.ts

@@ -1,120 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { describe, it, expect } from 'vitest';
-import { validate } from './validate.js';
-import { Schema } from '../schema.js';
-
-describe('validate', () => {
-    const userSchema: Schema = {
-        type: 'object',
-        properties: {
-            name: { type: 'string' },
-            age: { type: 'number' },
-            email: { type: 'string', pattern: '^[^@]+@[^@]+\\.[^@]+$' }
-        },
-        required: ['name', 'age', 'email']
-    };
-
-    it('should return empty array for valid data', () => {
-        const validData = {
-            name: 'John Doe',
-            age: 30,
-            email: 'john@example.com'
-        };
-
-        const errors = validate(userSchema, validData);
-        expect(errors).toEqual([]);
-    });
-
-    it('should return validation errors for invalid data', () => {
-        const invalidData = {
-            name: 'John Doe',
-            age: '30', // Should be a number
-            email: 'not-an-email'
-        };
-
-        const errors = validate(userSchema, invalidData);
-        expect(errors.length).toBeGreaterThan(0);
-        expect(errors).toContain('Property "age" does not match schema.');
-        expect(errors).toContain('Instance type "string" is invalid. Expected "number".');
-    });
-
-    it('should return errors for missing required fields', () => {
-        const incompleteData = {
-            name: 'John Doe'
-            // Missing age and email
-        };
-
-        const errors = validate(userSchema, incompleteData);
-        expect(errors.length).toBeGreaterThan(0);
-        expect(errors).toContain('Instance does not have required property "age".');
-        expect(errors).toContain('Instance does not have required property "email".');
-    });
-
-    it('should reuse validator instance for the same schema', () => {
-        const data1 = { name: 'John', age: 30, email: 'john@example.com' };
-        const data2 = { name: 'Jane', age: 25, email: 'jane@example.com' };
-
-        // First validation
-        const errors1 = validate(userSchema, data1);
-        expect(errors1).toEqual([]);
-
-        // Second validation with same schema
-        const errors2 = validate(userSchema, data2);
-        expect(errors2).toEqual([]);
-
-        // The validator should be reused from the WeakMap cache
-        // We can verify this by checking that the schema object is still the same reference
-        expect(userSchema).toBe(userSchema);
-    });
-
-    it('should handle nested schema validation', () => {
-        const nestedSchema: Schema = {
-            type: 'object',
-            properties: {
-                user: userSchema,
-                metadata: {
-                    type: 'object',
-                    properties: {
-                        createdAt: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$' }
-                    },
-                    required: ['createdAt']
-                }
-            },
-            required: ['user', 'metadata']
-        };
-
-        const validNestedData = {
-            user: {
-                name: 'John Doe',
-                age: 30,
-                email: 'john@example.com'
-            },
-            metadata: {
-                createdAt: '2024-03-20T12:00:00Z'
-            }
-        };
-
-        const errors = validate(nestedSchema, validNestedData);
-        expect(errors).toEqual([]);
-    });
-}); 

package/src/schema/validation/validate.ts

@@ -1,41 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { Validator, Schema as JsonSchema } from '@cfworker/json-schema';
-import { Schema } from "../schema.js";
-
-// Cache of validators using WeakMap to avoid memory leaks
-const validatorCache = new WeakMap<Schema, Validator>();
-
-export function validate(schema: Schema, data: any): string[] {
-    // Get or create validator from cache
-    let validator = validatorCache.get(schema);
-    if (!validator) {
-        validator = new Validator(schema as JsonSchema);
-        validatorCache.set(schema, validator);
-    }
-
-    const result = validator.validate(data);
-    if (result.valid) {
-        return [];
-    }
-    return result.errors.map((error) => error.error);
-}

package/src/schema/validation/with-validation.test.ts

@@ -1,112 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { describe, it, expect } from 'vitest';
-import { withValidation } from './with-validation.js';
-import { FromSchema } from '../index.js';
-
-// Define a test schema
-const userSchema = {
-    type: 'object',
-    properties: {
-        name: { type: 'string' },
-        age: { type: 'number' },
-        foo: { type: 'string' },
-        email: { type: 'string', format: 'email' }
-    },
-    required: ['name', 'age', 'email']
-} as const;
-
-describe('withValidation', () => {
-    it('should pass validation for valid input', () => {
-        const createUser = withValidation(userSchema)((user: FromSchema<typeof userSchema>) => user);
-
-        const validUser = {
-            name: 'John Doe',
-            age: 30,
-            email: 'john@example.com'
-        };
-
-        expect(() => createUser(validUser)).not.toThrow();
-        expect(createUser(validUser)).toEqual(validUser);
-    });
-
-    it('should throw error for invalid input', () => {
-        const createUser = withValidation(userSchema)((user: FromSchema<typeof userSchema>) => user);
-
-        const invalidUser = {
-            name: 'John Doe',
-            age: '30', // Should be a number
-            email: 'not-an-email'
-        };
-
-        expect(() => createUser(invalidUser as any)).toThrow(/Validation failed/);
-    });
-
-    it('should throw error for missing required fields', () => {
-        const createUser = withValidation(userSchema)((user: FromSchema<typeof userSchema>) => user);
-
-        const incompleteUser = {
-            name: 'John Doe',
-            // Missing age and email
-        };
-
-        expect(() => createUser(incompleteUser as any)).toThrow(/Validation failed/);
-    });
-
-    it('should preserve function return type', () => {
-        const processUser = withValidation(userSchema)(
-            (user: FromSchema<typeof userSchema>) => ({
-                ...user,
-                processed: true
-            })
-        );
-
-        const result = processUser({
-            name: 'John Doe',
-            age: 30,
-            email: 'john@example.com'
-        });
-
-        expect(result).toEqual({
-            name: 'John Doe',
-            age: 30,
-            email: 'john@example.com',
-            processed: true
-        });
-    });
-
-    it("should pass 'this' context to the wrapped function", () => {
-        const context = { value: 42 };
-        const fn = function (this: typeof context, user: FromSchema<typeof userSchema>) {
-            return this.value;
-        };
-        const wrapped = withValidation(userSchema)(fn);
-        const validUser = {
-            name: 'Jane Doe',
-            age: 25,
-            email: 'jane@example.com'
-        };
-        // Bind context and call
-        const result = wrapped.call(context, validUser);
-        expect(result).toBe(42);
-    });
-});