types: Update schema validation to use unknown.

optimal/src/createSchema.ts

@@ -20,7 +20,7 @@ import {
 function validate<T>(
 	state: SchemaState<T>,
 	validators: Criteria<T>[],
-	initialValue: T | null | undefined,
+	initialValue: unknown,
 	path: string = '',
 	{
 		collectErrors = true,
@@ -30,7 +30,7 @@ function validate<T>(
 ): T | null {
 	const { defaultValue, metadata } = state;
 
-	let value: T | null | undefined = initialValue;
+	let value: unknown = initialValue;
 
 	// Handle undefined
 	if (value === undefined) {
@@ -67,7 +67,7 @@ function validate<T>(
 
 		tryAndCollect(
 			() => {
-				const result = test.validate(value!, path, {
+				const result = test.validate(value as T, path, {
 					collectErrors,
 					currentObject,
 					rootObject,
@@ -86,7 +86,7 @@ function validate<T>(
 		throw optimalError;
 	}
 
-	return value!;
+	return value as T;
 }
 
 export function createSchema<S extends AnySchema, T = InferSchemaType<S>>(

optimal/src/schemas/date.ts

@@ -1,10 +1,10 @@
 import { createSchema } from '../createSchema';
 import { commonCriteria, dateCriteria } from '../criteria';
 import { createDate, invalid, isValidDate } from '../helpers';
-import { CommonCriterias, DateCriterias, DefaultValue, MaybeDate, Schema } from '../types';
+import { CommonCriterias, DateCriterias, DefaultValue, Schema } from '../types';
 
 export interface DateSchema<T = Date>
-	extends Schema<T, MaybeDate>,
+	extends Schema<T>,
 		DateCriterias<DateSchema<T>>,
 		CommonCriterias<DateSchema<T>> {
 	never: () => DateSchema<never>;

optimal/src/schemas/shape.ts

@@ -4,7 +4,7 @@ import { createObject, invalid, isObject } from '../helpers';
 import { Blueprint, CommonCriterias, InferNullable, Schema, ShapeCriterias } from '../types';
 
 export interface ShapeSchema<T>
-	extends Schema<T, Partial<T>>,
+	extends Schema<T>,
 		ShapeCriterias<ShapeSchema<T>>,
 		CommonCriterias<ShapeSchema<T>> {
 	never: () => ShapeSchema<never>;

optimal/src/types.ts

@@ -126,14 +126,10 @@ export interface SchemaValidateOptions {
 	rootObject?: UnknownObject;
 }
 
-export interface Schema<Output, Input = Output> {
+export interface Schema<Output> {
 	schema: () => string;
 	type: () => string;
-	validate: (
-		value: Input | null | undefined,
-		path?: string,
-		options?: SchemaValidateOptions,
-	) => Output;
+	validate: (value: unknown, path?: string, options?: SchemaValidateOptions) => Output;
 }
 
 export interface SchemaState<T> {
@@ -180,6 +176,6 @@ export type DeepPartial<T> = T extends Function
 
 // Any is required for generics to be typed correctly for consumers
 /* eslint-disable @typescript-eslint/no-explicit-any */
-export type AnySchema = Schema<any, any>;
+export type AnySchema = Schema<any>;
 
 export type AnyFunction = (...args: any[]) => any;

optimal/tests/schemas/array.test.ts

@@ -102,14 +102,12 @@ describe('array()', () => {
 
 		it('errors if a non-array is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be an array.');
 		});
 
 		it('errors if array value type is invalid', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate([123]);
 			}).toThrow('Must be a string.');
 		});

optimal/tests/schemas/blueprint.test.ts

@@ -21,14 +21,12 @@ describe('blueprint()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-object is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a plain object.');
 		});
 
 		it('errors if a value is not a schema', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({ foo: 123 });
 			}).toThrow('Must be a schema.');
 		});

optimal/tests/schemas/bool.test.ts

@@ -29,7 +29,6 @@ describe('bool()', () => {
 
 		it('errors if value is `true`', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				falseSchema.validate(true);
 			}).toThrow('May only be `false`.');
 		});
@@ -62,7 +61,6 @@ describe('bool()', () => {
 
 		it('errors if value is `false`', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				trueSchema.validate(false);
 			}).toThrow('May only be `true`.');
 		});
@@ -95,7 +93,6 @@ describe('bool()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-boolean is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a boolean.');
 		});

optimal/tests/schemas/custom.test.ts

@@ -62,7 +62,6 @@ describe('custom()', () => {
 
 		it('errors if a non-string is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a string!!!');
 		});

optimal/tests/schemas/date.test.ts

@@ -185,7 +185,6 @@ describe('date()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-date value is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate([]);
 			}).toThrow('Must be a string, number, or `Date` that resolves to a valid date.');
 		});

optimal/tests/schemas/func.test.ts

@@ -1,4 +1,4 @@
-import { AnyFunction,func, FunctionSchema, Infer } from '../../src';
+import { AnyFunction, func, FunctionSchema, Infer } from '../../src';
 import { runCommonTests } from './runCommonTests';
 
 describe('func()', () => {
@@ -27,7 +27,6 @@ describe('func()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-function is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a function.');
 		});

optimal/tests/schemas/lazy.test.ts

@@ -119,7 +119,6 @@ describe('lazy()', () => {
 
 		it('errors if valid values the lazy schema', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a string.');
 

optimal/tests/schemas/number.test.ts

@@ -31,7 +31,6 @@ describe('number()', () => {
 
 		it('errors if number is not in list', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				oneOfSchema.validate(5);
 			}).toThrow('Number must be one of: 1, 2, 3');
 		});
@@ -321,7 +320,6 @@ describe('number()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-number is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate('abc');
 			}).toThrow('Must be a number.');
 		});

optimal/tests/schemas/object.test.ts

@@ -142,14 +142,12 @@ describe('object()', () => {
 
 		it('errors if a non-object is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a plain object.');
 		});
 
 		it('errors if object value type is invalid', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({ a: 123 });
 			}).toThrow('Must be a string.');
 		});

optimal/tests/schemas/regex.test.ts

@@ -24,14 +24,12 @@ describe('regex()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-object is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be an instance of RegExp.');
 		});
 
 		it('errors if a plain object is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({});
 			}).toThrow('Must be an instance of RegExp.');
 		});

optimal/tests/schemas/schema.test.ts

@@ -23,7 +23,6 @@ describe('schema()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-object is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a schema.');
 		});
@@ -36,21 +35,18 @@ describe('schema()', () => {
 
 		it('errors if a schema is not a function', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({ schema: 123 });
 			}).toThrow('Must be a function.');
 		});
 
 		it('errors if a type is not a function', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({ schema() {}, type: 123 });
 			}).toThrow('Must be a function.');
 		});
 
 		it('errors if a validate is not a function', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate({ schema() {}, type() {}, validate: 123 });
 			}).toThrow('Must be a function.');
 		});

optimal/tests/schemas/shape.test.ts

@@ -60,7 +60,6 @@ describe('shape()', () => {
 
 		it('errors if unknown properties passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				exactSchema.validate({ foo: '', bar: 0, baz: true, qux: 'unknown' });
 			}).toThrow('Unknown fields: qux.');
 		});
@@ -107,7 +106,6 @@ describe('shape()', () => {
 
 		it('errors if a non-shape is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a shaped object.');
 		});

optimal/tests/schemas/string.test.ts

@@ -352,7 +352,6 @@ describe('string()', () => {
 
 		it('errors if value is not in the list', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				oneOfSchema.validate('qux');
 			}).toThrowErrorMatchingInlineSnapshot(`"String must be one of: foo, bar, baz"`);
 		});
@@ -571,7 +570,6 @@ describe('string()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-string is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a string.');
 		});

optimal/tests/schemas/tuple.test.ts

@@ -58,14 +58,12 @@ describe('tuple()', () => {
 	describe('validateType()', () => {
 		it('errors if a non-tuple is passed', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate(123);
 			}).toThrow('Must be a tuple.');
 		});
 
 		it('errors if the first tuple item is invalid', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate([null, false, 4, {}, 'foo']);
 			}).toThrow('Null is not allowed.');
 		});
@@ -78,7 +76,6 @@ describe('tuple()', () => {
 
 		it('errors if the last tuple item is invalid', () => {
 			expect(() => {
-				// @ts-expect-error Invalid type
 				schema.validate([[], false, 4, {}, 'qux']);
 			}).toThrow('String must be one of: foo, bar, baz');
 		});
@@ -110,7 +107,6 @@ describe('tuple()', () => {
 		});
 
 		it('returns the default value from its items when an empty array is passed', () => {
-			// @ts-expect-error Invalid type
 			expect(schema.validate([])).toEqual([[], true, 1, {}, 'foo']);
 		});
 	});