@adobe/data 0.1.3 → 0.2.1

package/src/schema/schema.ts

@@ -0,0 +1,229 @@
+/*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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,26 @@
+/*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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,31 @@
+/*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/{core/schema/validation/is-valid.test.js → src/schema/validation/is-valid.test.ts}

@@ -21,20 +21,23 @@ 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 = {
+    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);
     });
-});
-//# sourceMappingURL=is-valid.test.js.map
+}); 

package/{core/functions/array-equals.js → src/schema/validation/is-valid.ts}

@@ -19,16 +19,14 @@ 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.*/
-export function arrayEquals(a, b) {
-    const length = a.length;
-    if (length !== b.length) {
+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;
     }
-    for (let i = 0; i < length; i++) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
 }
-//# sourceMappingURL=array-equals.js.map

package/{core/schema/validation/validate.test.js → src/schema/validation/validate.test.ts}

@@ -21,8 +21,10 @@ 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 = {
+    const userSchema: Schema = {
         type: 'object',
         properties: {
             name: { type: 'string' },
@@ -31,51 +33,62 @@ describe('validate', () => {
         },
         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 = {
+        const nestedSchema: Schema = {
             type: 'object',
             properties: {
                 user: userSchema,
@@ -89,6 +102,7 @@ describe('validate', () => {
             },
             required: ['user', 'metadata']
         };
+
         const validNestedData = {
             user: {
                 name: 'John Doe',
@@ -99,8 +113,8 @@ describe('validate', () => {
                 createdAt: '2024-03-20T12:00:00Z'
             }
         };
+
         const errors = validate(nestedSchema, validNestedData);
         expect(errors).toEqual([]);
     });
-});
-//# sourceMappingURL=validate.test.js.map
+}); 

package/{core/schema/validation/validate.js → src/schema/validation/validate.ts}

@@ -19,20 +19,23 @@ 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 } from '@cfworker/json-schema';
+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();
-export function validate(schema, data) {
+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);
+        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);
-}
-//# sourceMappingURL=validate.js.map
+}

package/{core/functions/with-validation.test.js → src/schema/validation/with-validation.test.ts}

@@ -21,6 +21,8 @@ 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',
@@ -31,45 +33,59 @@ const userSchema = {
         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) => user);
+        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) => user);
+        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)).toThrow(/Validation failed/);
+
+        expect(() => createUser(invalidUser as any)).toThrow(/Validation failed/);
     });
+
     it('should throw error for missing required fields', () => {
-        const createUser = withValidation(userSchema)((user) => user);
+        const createUser = withValidation(userSchema)((user: FromSchema<typeof userSchema>) => user);
+
         const incompleteUser = {
             name: 'John Doe',
             // Missing age and email
         };
-        expect(() => createUser(incompleteUser)).toThrow(/Validation failed/);
+
+        expect(() => createUser(incompleteUser as any)).toThrow(/Validation failed/);
     });
+
     it('should preserve function return type', () => {
-        const processUser = withValidation(userSchema)((user) => ({
-            ...user,
-            processed: true
-        }));
+        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,
@@ -77,9 +93,10 @@ describe('withValidation', () => {
             processed: true
         });
     });
+
     it("should pass 'this' context to the wrapped function", () => {
         const context = { value: 42 };
-        const fn = function (user) {
+        const fn = function (this: typeof context, user: FromSchema<typeof userSchema>) {
             return this.value;
         };
         const wrapped = withValidation(userSchema)(fn);
@@ -93,4 +110,3 @@ describe('withValidation', () => {
         expect(result).toBe(42);
     });
 });
-//# sourceMappingURL=with-validation.test.js.map

package/{core/functions/with-validation.js → src/schema/validation/with-validation.ts}

@@ -19,20 +19,24 @@ 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 } from '@cfworker/json-schema';
+import { Schema, FromSchema } from '../index.js';
+import { validate } from './validate.js';
+
 /**
  * Creates a function which can wrap another function and validate the input against a JSON Schema.
  */
-export function withValidation(schema) {
-    const validator = new Validator(schema);
-    return function (fn) {
-        return function (arg) {
-            const validation = validator.validate(arg);
-            if (!validation.valid) {
-                throw new Error(`Validation failed: ${JSON.stringify(validation.errors)}`);
+export function withValidation<T extends Schema>(schema: T) {
+    return function <F extends (arg: FromSchema<T>) => any>(fn: F): F {
+        return function (this: any, arg: FromSchema<T>) {
+            const errors = validate(schema, arg);
+
+            if (errors.length > 0) {
+                throw new Error(
+                    `Validation failed: ${JSON.stringify(errors)}`
+                );
             }
+
             return fn.call(this, arg);
-        };
+        } as F;
     };
 }
-//# sourceMappingURL=with-validation.js.map

package/src/schema.test.ts

@@ -0,0 +1,55 @@
+/*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 FromSchema, type Schema } from "./schema/index.js";
+import { type Extends, type False, type True } from "./types/types.js";
+import { describe, it } from "vitest";
+
+describe("Schema", () => {
+  it("should provide compile time and runtime type validation", () => {
+    const mySchema = {
+      type: "object",
+      required: ["name", "aspect"],
+      properties: {
+        name: { type: "string" },
+        age: { type: "integer", minimum: 0 },
+        aspect: { enum: ["landscape", "portrait"] },
+      },
+      additionalProperties: false,
+    } as const satisfies Schema;
+    type MyType = FromSchema<typeof mySchema>;
+
+    //  compile time type checking.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type ShouldBeValid = True<
+      Extends<{ name: "foo"; aspect: "landscape" }, MyType>
+    >;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type WrongAspect = False<Extends<{ name: "foo"; aspect: "wrong" }, MyType>>;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type MissingAspect = False<Extends<{ name: "foo" }, MyType>>;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars -- compile time type check
+    type ExtraPropertyCannotBeTypescriptTypeChecked = True<
+      Extends<{ name: "foo"; aspect: "landscape"; agewrong: 1 }, MyType>
+    >;
+  });
+});