@oscarpalmer/jhunal 0.23.0 → 0.25.0

package/dist/models/transform.model.d.mts

@@ -1,5 +1,5 @@
-import { TypedSchema } from "./schema.typed.model.mjs";
-import { Schematic } from "../schematic.mjs";
+import { TypedSchematic } from "./schematic.typed.model.mjs";
+import { Schema } from "../schema.mjs";
 import { DeduplicateTuple, UnionToTuple, UnwrapSingle, Values } from "./misc.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 
@@ -25,11 +25,11 @@ type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaProp
 /**
  * Converts a single type to its schema property equivalent
  *
- * Plain objects become {@link TypedSchema}; primitives go through {@link ToValueType}
+ * Plain objects become {@link TypedSchematic}; primitives go through {@link ToValueType}
  *
  * @template Value Type to convert
  */
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchematic<Value> : ToValueType<Value>;
 /**
  * Converts a TypeScript type to its {@link ValueName} representation, suitable for use as a top-level schema entry
  *
@@ -39,7 +39,7 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
 /**
  * Maps a type to its {@link ValueName} string equivalent
  *
- * Resolves {@link Schematic} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
+ * Resolves {@link Schema} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
  *
  * @template Value Type to map
  *
@@ -50,6 +50,6 @@ type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionTo
  * // ToValueType<Date>      => 'date'
  * ```
  */
-type ToValueType<Value> = Value extends Schematic<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
+type ToValueType<Value> = Value extends Schema<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
 //#endregion
 export { MapToSchemaPropertyTypes, MapToValueTypes, ToSchemaPropertyType, ToSchemaPropertyTypeEach, ToSchemaType, ToValueType };

package/dist/models/validation.model.d.mts

@@ -1,4 +1,4 @@
-import { Schematic } from "../schematic.mjs";
+import { Schema } from "../schema.mjs";
 import { ValueName } from "./misc.model.mjs";
 import { GenericCallback, PlainObject } from "@oscarpalmer/atoms/models";
 
@@ -70,6 +70,16 @@ type GetOptions<Errors extends ReportingType> = BaseOptions<Errors> & {
  */
 type IsOptions<Errors extends ReportingType> = BaseOptions<Errors>;
 type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => true | ValidationInformation[];
+type ValidatorDefaults = {
+  value: unknown;
+};
+type ValidatorItem = {
+  defaults: ValidatorDefaults | undefined;
+  key: ValidationInformationKey;
+  required: boolean;
+  types: ValidatorType[];
+  validator: Validator;
+};
 type ValidatorParameters = {
   clone: boolean;
   information?: ValidationInformation[];
@@ -77,6 +87,6 @@ type ValidatorParameters = {
   reporting: ReportingInformation;
   strict: boolean;
 };
-type ValidatorType = Function | PlainObject | Schematic<unknown> | ValueName;
+type ValidatorType = Function | PlainObject | Schema<unknown> | ValueName;
 //#endregion
-export { GetOptions, IsOptions, NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, Validator, ValidatorParameters, ValidatorType };
+export { GetOptions, IsOptions, NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, Validator, ValidatorDefaults, ValidatorItem, ValidatorParameters, ValidatorType };

package/dist/{schematic.d.mts → schema.d.mts}

@@ -1,17 +1,17 @@
 import { Infer } from "./models/infer.model.mjs";
-import { TypedSchema } from "./models/schema.typed.model.mjs";
+import { TypedSchematic } from "./models/schematic.typed.model.mjs";
 import { GetOptions, IsOptions, ValidationInformation, Validator } from "./models/validation.model.mjs";
-import { Schema } from "./models/schema.plain.model.mjs";
+import { Schematic } from "./models/schematic.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/models";
 
-//#region src/schematic.d.ts
+//#region src/schema.d.ts
 /**
- * A schematic for validating objects
+ * A schema for validating objects
  */
-declare class Schematic<Model> {
+declare class Schema<Model> {
   #private;
-  private readonly $schematic;
+  private readonly $schema;
   constructor(validator: Validator);
   /**
    * Parse a value according to the schema
@@ -159,21 +159,21 @@ declare class Schematic<Model> {
   is(value: unknown, strict?: true): value is Model;
 }
 /**
- * Create a schematic from a schema
+ * Create a schema from a schematic
  * @template Model Schema type
- * @param schema Schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given schema
+ * @param schema Schematic to create the schema from
+ * @throws Throws {@link SchematicError} if the schematic can not be converted into a schema
+ * @returns A schema for the given schematic
  */
-declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
+declare function schema<Model extends Schematic>(schema: Model): Schema<Infer<Model>>;
 /**
- * Create a schematic from a typed schema
+ * Create a schema from a typed schematic
  * @template Model Existing type
- * @param schema Typed schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given typed schema
+ * @param schema Typed schematic to create the schema from
+ * @throws Throws {@link SchematicError} if the schematic can not be converted into a schema
+ * @returns A schema for the given typed schematic
  */
-declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
-declare const schematicValidator: WeakMap<Schematic<unknown>, Validator>;
+declare function schema<Model extends PlainObject>(schema: TypedSchematic<Model>): Schema<Model>;
+declare const schemaValidators: WeakMap<Schema<unknown>, Validator>;
 //#endregion
-export { Schematic, schematic, schematicValidator };
+export { Schema, schema, schemaValidators };

package/dist/{schematic.mjs → schema.mjs}

@@ -1,19 +1,19 @@
-import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getParameters, isSchematic } from "./helpers/misc.helper.mjs";
+import { PROPERTY_SCHEMA, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
+import { getParameters, isSchema } from "./helpers/misc.helper.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
 import { getObjectValidator } from "./validator/object.validator.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { error, ok } from "@oscarpalmer/atoms/result/misc";
-//#region src/schematic.ts
+//#region src/schema.ts
 /**
-* A schematic for validating objects
+* A schema for validating objects
 */
-var Schematic = class {
+var Schema = class {
 	#validator;
 	constructor(validator) {
-		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
+		Object.defineProperty(this, PROPERTY_SCHEMA, { value: true });
 		this.#validator = validator;
-		schematicValidator.set(this, validator);
+		schemaValidators.set(this, validator);
 	}
 	get(value, options) {
 		const parameters = getParameters(options);
@@ -30,11 +30,11 @@ var Schematic = class {
 		return error(parameters.reporting.all ? result : result[0]);
 	}
 };
-function schematic(schema) {
-	if (isSchematic(schema)) return schema;
+function schema(schema) {
+	if (isSchema(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getObjectValidator(schema));
+	return new Schema(getObjectValidator(schema));
 }
-const schematicValidator = /* @__PURE__ */ new WeakMap();
+const schemaValidators = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { Schematic, schematic, schematicValidator };
+export { Schema, schema, schemaValidators };

package/dist/validator/named.handler.d.mts

@@ -1,6 +1,6 @@
 import { NamedValidatorHandlers } from "../models/validation.model.mjs";
 
 //#region src/validator/named.handler.d.ts
-declare function getNamedHandlers(original: unknown, prefix: string): NamedValidatorHandlers;
+declare function getNamedHandlers(original: unknown, prefix: string, allowed: boolean): NamedValidatorHandlers;
 //#endregion
 export { getNamedHandlers };

package/dist/validator/named.handler.mjs

@@ -1,9 +1,10 @@
-import { SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "../constants.mjs";
+import { PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "../constants.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/validator/named.handler.ts
-function getNamedHandlers(original, prefix) {
+function getNamedHandlers(original, prefix, allowed) {
 	const handlers = {};
 	if (original == null) return handlers;
+	if (!allowed) throw new TypeError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", PROPERTY_VALIDATORS));
 	if (!isPlainObject(original)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
 	const keys = Object.keys(original);
 	const { length } = keys;

package/dist/validator/named.validator.mjs

@@ -1,5 +1,4 @@
-import "../constants.mjs";
-import { getInvalidValidatorMessage } from "../helpers/message.helper.mjs";
+import { getInputPropertyValidatorMessage } from "../helpers/message.helper.mjs";
 //#region src/validator/named.validator.ts
 function getNamedValidator(key, name, handlers) {
 	const validator = namedValidators[name];
@@ -13,7 +12,7 @@ function getNamedValidator(key, name, handlers) {
 			const information = {
 				key,
 				validator,
-				message: getInvalidValidatorMessage(key.full, name, index, length),
+				message: getInputPropertyValidatorMessage(key.full, name, index, length),
 				value: input
 			};
 			parameters.information?.push(information);

package/dist/validator/object.validator.mjs

@@ -1,17 +1,23 @@
-import { PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, TYPE_ALL } from "../constants.mjs";
-import { isSchematic } from "../helpers/misc.helper.mjs";
+import { PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, TYPE_ALL } from "../constants.mjs";
+import { getParameters, isSchema } from "../helpers/misc.helper.mjs";
 import { SchematicError, ValidationError } from "../models/validation.model.mjs";
-import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
+import { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
 import { getBaseValidator } from "./base.validator.mjs";
 import { getFunctionValidator } from "./function.validator.mjs";
 import { getNamedHandlers } from "./named.handler.mjs";
 import { getNamedValidator } from "./named.validator.mjs";
-import { getSchematicValidator } from "./schematic.validator.mjs";
+import { getSchemaValidator } from "./schematic.validator.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
 import { clone } from "@oscarpalmer/atoms/value/clone";
 //#region src/validator/object.validator.ts
+function getDefaults(obj, key, allowed) {
+	if (!("$default" in obj)) return;
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
+	return { value: obj[PROPERTY_DEFAULT] };
+}
 function getDisallowedProperty(obj) {
+	if ("$default" in obj) return PROPERTY_DEFAULT;
 	if ("$required" in obj) return PROPERTY_REQUIRED;
 	if ("$type" in obj) return PROPERTY_TYPE;
 	if ("$validators" in obj) return PROPERTY_VALIDATORS;
@@ -22,14 +28,14 @@ function getObjectValidator(original, origin, fromType) {
 	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
 	if (fromType ?? false) {
 		const property = getDisallowedProperty(original);
-		if (property != null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", origin.full).replace("<>", property));
+		if (property != null) throw new SchematicError(getDisallowedMessage(origin.full, property));
 	}
 	const set = /* @__PURE__ */ new Set();
 	const items = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 		const value = original[key];
-		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([origin?.full, key], ".")));
+		if (value == null) throw new SchematicError(getSchematicPropertyNullableMessage(join([origin?.full, key], ".")));
 		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
 		const fullKey = {
 			full: prefixedKey,
@@ -38,16 +44,18 @@ function getObjectValidator(original, origin, fromType) {
 		let handlers = {};
 		let required = true;
 		let typed = false;
+		let defaults;
 		let types;
 		const validators = [];
 		if (isPlainObject(value)) {
 			typed = PROPERTY_TYPE in value;
 			const type = typed ? value[PROPERTY_TYPE] : value;
-			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey);
-			required = getRequired(key, value) ?? required;
+			defaults = getDefaults(value, prefixedKey, typed);
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey, typed);
+			required = getRequired(value, prefixedKey, typed) ?? required;
 			types = Array.isArray(type) ? type : [type];
 		} else types = Array.isArray(value) ? value : [value];
-		if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(value)));
+		if (types.length === 0) throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
 		const typesLength = types.length;
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
@@ -59,23 +67,28 @@ function getObjectValidator(original, origin, fromType) {
 				case isPlainObject(type):
 					validator = getObjectValidator(type, fullKey, typed);
 					break;
-				case isSchematic(type):
-					validator = getSchematicValidator(type);
+				case isSchema(type):
+					validator = getSchemaValidator(type);
 					break;
 				case TYPE_ALL.has(type):
 					validator = getNamedValidator(fullKey, type, handlers);
 					break;
-				default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(type)));
+				default: throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
 			}
 			validators.push(validator);
 		}
-		set.add(key);
+		required = required && !types.includes("undefined");
+		if (defaults != null && !required) throw new SchematicError(getDefaultRequiredMessage(prefixedKey));
+		const validator = getBaseValidator(validators);
+		if (defaults != null && Array.isArray(validator(defaults.value, getParameters(), false))) throw new SchematicError(getDefaultTypeMessage(prefixedKey, types));
 		items.push({
+			defaults,
+			required,
 			types,
-			key: fullKey,
-			required: required && !types.includes("undefined"),
-			validator: getBaseValidator(validators)
+			validator,
+			key: fullKey
 		});
+		set.add(key);
 	}
 	const validatorsLength = items.length;
 	return (input, parameters, get) => {
@@ -87,7 +100,7 @@ function getObjectValidator(original, origin, fromType) {
 					short: ""
 				},
 				value: input,
-				message: getInvalidInputMessage(input)
+				message: getInputTypeMessage(input)
 			};
 			if (parameters.reporting.throw) throw new ValidationError([information]);
 			parameters.information?.push(information);
@@ -112,15 +125,19 @@ function getObjectValidator(original, origin, fromType) {
 		const allInformation = [];
 		const output = {};
 		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
-			const { key, required, types, validator } = items[validatorIndex];
+			const { defaults, key, required, types, validator } = items[validatorIndex];
 			const value = input[key.short];
 			if (value === void 0) {
 				if (required) {
+					if (get && defaults != null) {
+						output[key.short] = clone(defaults.value);
+						continue;
+					}
 					if (parameters.reporting.none) return [];
 					const information = {
 						key,
 						value,
-						message: getInvalidMissingMessage(key.full, types)
+						message: getInputPropertyMissingMessage(key.full, types)
 					};
 					if (parameters.reporting.throw) throw new ValidationError([information]);
 					parameters.information?.push(information);
@@ -144,7 +161,7 @@ function getObjectValidator(original, origin, fromType) {
 			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
 				key,
 				value,
-				message: getInvalidTypeMessage(key.full, types, value)
+				message: getInputPropertyTypeMessage(key.full, types, value)
 			}];
 			if (parameters.reporting.throw) throw new ValidationError(information);
 			if (parameters.reporting.all) {
@@ -158,9 +175,10 @@ function getObjectValidator(original, origin, fromType) {
 		return allInformation.length === 0 ? true : allInformation;
 	};
 }
-function getRequired(key, obj) {
+function getRequired(obj, key, allowed) {
 	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
 	return obj[PROPERTY_REQUIRED];
 }
 //#endregion

package/dist/validator/schematic.validator.d.mts

@@ -1,7 +1,7 @@
 import { Validator } from "../models/validation.model.mjs";
-import { Schematic } from "../schematic.mjs";
+import { Schema } from "../schema.mjs";
 
 //#region src/validator/schematic.validator.d.ts
-declare function getSchematicValidator(schematic: Schematic<unknown>): Validator;
+declare function getSchemaValidator(schematic: Schema<unknown>): Validator;
 //#endregion
-export { getSchematicValidator };
+export { getSchemaValidator };

package/dist/validator/schematic.validator.mjs

@@ -1,8 +1,8 @@
-import { schematicValidator } from "../schematic.mjs";
+import { schemaValidators } from "../schema.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/validator/schematic.validator.ts
-function getSchematicValidator(schematic) {
-	const validator = schematicValidator.get(schematic);
+function getSchemaValidator(schematic) {
+	const validator = schemaValidators.get(schematic);
 	return (input, parameters, get) => {
 		let result;
 		if (isPlainObject(input)) result = validator(input, parameters, get);
@@ -13,4 +13,4 @@ function getSchematicValidator(schematic) {
 	};
 }
 //#endregion
-export { getSchematicValidator };
+export { getSchemaValidator };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/jhunal",
-	"version": "0.23.0",
+	"version": "0.25.0",
 	"description": "Flies free beneath the glistening moons…",
 	"keywords": [
 		"schema",

package/src/constants.ts

@@ -23,9 +23,9 @@ export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 // #region Names
 
-export const NAME_SCHEMATIC = 'Schematic';
+export const NAME_SCHEMA = 'Schema';
 
-export const NAME_SCHEMATIC_PREFIXED = 'a Schematic';
+export const NAME_SCHEMA_PREFIXED = 'a Schema';
 
 export const NAME_ERROR_SCHEMATIC = 'SchematicError';
 
@@ -35,9 +35,11 @@ export const NAME_ERROR_VALIDATION = 'ValidationError';
 
 // #region Properties
 
+export const PROPERTY_DEFAULT = '$default';
+
 export const PROPERTY_REQUIRED = '$required';
 
-export const PROPERTY_SCHEMATIC = '$schematic';
+export const PROPERTY_SCHEMA = '$schema';
 
 export const PROPERTY_TYPE = '$type';
 
@@ -83,10 +85,16 @@ export const REPORTING_TYPES = new Set<ReportingType>([
 
 // #region Schematic validation
 
+export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED =
+	"'<>' has a default value but is not required";
+
+export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE =
+	"Expected default value for property '<>' to be <>";
+
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
 
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED =
-	"'<>.<>' property is not allowed for schemas in $type";
+	"'<>.<>' property is not allowed for plain schemas";
 
 export const SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE =
 	"'<>' property must not be 'null' or 'undefined'";
@@ -118,52 +126,40 @@ export const TEMPLATE_PATTERN = '<>';
 
 export const TYPE_ARRAY = 'array';
 
-const TYPE_BIGINT = 'bigint';
-
-const TYPE_BOOLEAN = 'boolean';
-
-const TYPE_DATE = 'date';
-
 export const TYPE_FUNCTION = 'function';
 
 export const TYPE_FUNCTION_RESULT = 'a validated value';
 
 export const TYPE_NULL = 'null';
 
-const TYPE_NUMBER = 'number';
-
 export const TYPE_OBJECT = 'object';
 
-const TYPE_STRING = 'string';
-
-const TYPE_SYMBOL = 'symbol';
-
 export const TYPE_UNDEFINED = 'undefined';
 
 export const VALIDATABLE_TYPES = new Set<ValueName>([
 	TYPE_ARRAY,
-	TYPE_BIGINT,
-	TYPE_BOOLEAN,
-	TYPE_DATE,
+	'bigint',
+	'boolean',
+	'date',
 	TYPE_FUNCTION,
-	TYPE_NUMBER,
+	'number',
 	TYPE_OBJECT,
-	TYPE_STRING,
-	TYPE_SYMBOL,
+	'string',
+	'symbol',
 ]);
 
 export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, TYPE_NULL, TYPE_UNDEFINED]);
 
 export const PREFIXED_TYPES: Record<ValueName, string> = {
 	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
-	[TYPE_BIGINT]: `a ${TYPE_BIGINT}`,
-	[TYPE_BOOLEAN]: `a ${TYPE_BOOLEAN}`,
-	[TYPE_DATE]: `a ${TYPE_DATE}`,
+	bigint: `a bigint`,
+	boolean: `a boolean`,
+	date: `a date`,
 	[TYPE_FUNCTION]: `a ${TYPE_FUNCTION}`,
 	[TYPE_NULL]: TYPE_NULL,
-	[TYPE_NUMBER]: `a ${TYPE_NUMBER}`,
-	[TYPE_STRING]: `a ${TYPE_STRING}`,
-	[TYPE_SYMBOL]: `a ${TYPE_SYMBOL}`,
+	number: `a number`,
+	string: `a string`,
+	symbol: `a symbol`,
 	[TYPE_OBJECT]: `an ${TYPE_OBJECT}`,
 	[TYPE_UNDEFINED]: TYPE_UNDEFINED,
 };

package/src/helpers/message.helper.ts

@@ -6,10 +6,15 @@ import {
 	CONJUNCTION_OR,
 	CONJUNCTION_OR_COMMA,
 	PREFIXED_TYPES,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
 	TEMPLATE_PATTERN,
 	TYPE_ALL,
 	TYPE_ARRAY,
-	TYPE_FUNCTION,
 	TYPE_FUNCTION_RESULT,
 	TYPE_NULL,
 	TYPE_OBJECT,
@@ -23,11 +28,41 @@ import {
 import type {ValueName} from '../models/misc.model';
 import type {ValidatorType} from '../models/validation.model';
 
-export function getInvalidInputMessage(actual: unknown): string {
+// #region Defaults
+
+export function getDefaultRequiredMessage(key: string): string {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_REQUIRED.replace(TEMPLATE_PATTERN, key);
+}
+
+export function getDefaultTypeMessage(key: string, types: ValidatorType[]): string {
+	let message = SCHEMATIC_MESSAGE_SCHEMA_INVALID_DEFAULT_TYPE.replace(TEMPLATE_PATTERN, key);
+
+	message = message.replace(TEMPLATE_PATTERN, renderTypes(types));
+
+	return message;
+}
+
+// #endregion
+
+// #region Disallowed
+
+export function getDisallowedMessage(key: string, property: string): string {
+	let message = SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN, key);
+
+	message = message.replace(TEMPLATE_PATTERN, property);
+
+	return message;
+}
+
+// #endregion
+
+// #region Input
+
+export function getInputTypeMessage(actual: unknown): string {
 	return VALIDATION_MESSAGE_INVALID_INPUT.replace(TEMPLATE_PATTERN, getValueType(actual));
 }
 
-export function getInvalidMissingMessage(key: string, types: ValidatorType[]): string {
+export function getInputPropertyMissingMessage(key: string, types: ValidatorType[]): string {
 	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace(TEMPLATE_PATTERN, renderTypes(types));
 
 	message = message.replace(TEMPLATE_PATTERN, key);
@@ -35,7 +70,7 @@ export function getInvalidMissingMessage(key: string, types: ValidatorType[]): s
 	return message;
 }
 
-export function getInvalidTypeMessage(
+export function getInputPropertyTypeMessage(
 	key: string,
 	types: ValidatorType[],
 	actual: unknown,
@@ -48,7 +83,7 @@ export function getInvalidTypeMessage(
 	return message;
 }
 
-export function getInvalidValidatorMessage(
+export function getInputPropertyValidatorMessage(
 	key: string,
 	type: ValueName,
 	index: number,
@@ -65,6 +100,22 @@ export function getInvalidValidatorMessage(
 	return message;
 }
 
+// #endregion
+
+// #region Schematic
+
+export function getSchematicPropertyNullableMessage(key: string): string {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace(TEMPLATE_PATTERN, key);
+}
+
+export function getSchematicPropertyTypeMessage(key: string): string {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key);
+}
+
+// #endregion
+
+// #region Misc.
+
 function getPropertyType(type: ValidatorType): string {
 	switch (true) {
 		case typeof type === 'function':
@@ -78,10 +129,6 @@ function getPropertyType(type: ValidatorType): string {
 	}
 }
 
-export function getUnknownKeysMessage(keys: string[]): string {
-	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace(TEMPLATE_PATTERN, renderKeys(keys));
-}
-
 function getValueType(value: unknown): string {
 	const valueType = typeof value;
 
@@ -150,3 +197,21 @@ function renderTypes(types: ValidatorType[]): string {
 
 	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
 }
+
+// #endregion
+
+// #region Required
+
+export function getRequiredMessage(key: string): string {
+	return SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key);
+}
+
+// #endregion
+
+// #region Strictness
+
+export function getUnknownKeysMessage(keys: string[]): string {
+	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace(TEMPLATE_PATTERN, renderKeys(keys));
+}
+
+// #endregion