@warlock.js/notifications 5.30.0 → 5.32.0

package/esm/packages/seal/src/validators/object-validator.mjs

@@ -1,445 +0,0 @@
-import { applyNullable, wrapNullableStrict } from "../standard-schema/json-schema.mjs";
-import { except } from "../../../../node_modules/.pnpm/@mongez_reinforcements@4.0.2/node_modules/@mongez/reinforcements/esm/object/except.mjs";
-import "../../../../node_modules/.pnpm/@mongez_reinforcements@4.0.2/node_modules/@mongez/reinforcements/esm/index.mjs";
-import { isPlainObject } from "../../../../node_modules/.pnpm/@mongez_supportive-is@3.0.0/node_modules/@mongez/supportive-is/esm/index.mjs";
-import { setKeyPath } from "../helpers/path-helpers.mjs";
-import { BaseValidator } from "./base-validator.mjs";
-import { objectTrimMutator, stripUnknownMutator } from "../mutators/object-mutators.mjs";
-import { objectRule } from "../rules/common/type-rules.mjs";
-import { unknownKeyRule } from "../rules/common/unknown-key.mjs";
-import { ComputedValidator } from "./computed-validator.mjs";
-
-//#region ../../packages/seal/src/validators/object-validator.ts
-/**
-* Object validator class with generic schema type for proper type inference.
-*
-* Threads two distinct inferred shapes into `BaseValidator`'s `TInput`/`TOutput`:
-*
-* - `TInput`  = `InferInputObjectShape<TSchema>`  — what `~standard.validate()`
-*               accepts (caller's pre-validation payload; defaults/catches make
-*               keys optional)
-* - `TOutput` = `InferOutputObjectShape<TSchema>` — what `~standard.validate()`
-*               returns on success (post-default, post-catch shape; guaranteed
-*               keys are required)
-*
-* Both helpers are used directly (not the full `Infer.*` walker) to avoid a
-* recursive class-base evaluation that would otherwise occur when the
-* brand-aware widening tries to inspect the class type.
-*/
-var ObjectValidator = class ObjectValidator extends BaseValidator {
-	schema;
-	shouldAllowUnknown = false;
-	allowedKeys = [];
-	hasUnknownKeyRule = false;
-	constructor(schema, errorMessage) {
-		super();
-		this.schema = schema;
-		this.addMutableRule(objectRule, errorMessage);
-	}
-	/**
-	* Check if value is an object type (plain object, not array or date)
-	*/
-	matchesType(value) {
-		return isPlainObject(value);
-	}
-	/** Strip unknown keys from the data */
-	stripUnknown() {
-		const validator = this.instance;
-		return validator.addMutator(stripUnknownMutator, { get allowedKeys() {
-			return validator.allowedKeys;
-		} });
-	}
-	/** Add list of allowed keys that could be in the data but not necessarily validated */
-	allow(...keys) {
-		const validator = this.instance;
-		validator.allowedKeys.push(...keys);
-		return validator;
-	}
-	/** Trim values of the object properties */
-	trim(recursive = true) {
-		return this.instance.addMutator(objectTrimMutator, { recursive });
-	}
-	/** Whether to allow unknown properties
-	* Please note it will allow only unknown direct children keys, not nested children keys
-	*/
-	allowUnknown(allow = true) {
-		const validator = this.instance;
-		validator.shouldAllowUnknown = allow;
-		return validator;
-	}
-	/**
-	* Create a copy of this object validator with the same configuration
-	* Copies schema, rules, mutators, transformers, and object-specific settings
-	*
-	* @returns A new ObjectValidator instance with copied configuration
-	*
-	* @example
-	* ```ts
-	* const baseUser = v.object({ name: v.string() }).allowUnknown();
-	* const userCopy = baseUser.clone();
-	* // userCopy has the same schema and allowUnknown setting
-	* ```
-	*/
-	clone(keys) {
-		const cloned = super.clone();
-		const newSchema = {};
-		for (const [key, validator] of Object.entries(this.schema)) {
-			if (keys && !keys.includes(key)) continue;
-			newSchema[key] = validator.clone();
-		}
-		cloned.schema = newSchema;
-		cloned.shouldAllowUnknown = this.shouldAllowUnknown;
-		cloned.allowedKeys = [...this.allowedKeys];
-		return cloned;
-	}
-	/**
-	* Extend this schema with additional fields
-	* Clones the current validator and adds new fields to the schema
-	* **Keeps original configuration** (allowUnknown, stripUnknown, etc.)
-	*
-	* If an ObjectValidator is provided, only its schema is used - its configuration is ignored.
-	* This is useful for creating reusable field collections that can be added to different schemas.
-	*
-	* @param schemaOrValidator - Plain schema object or ObjectValidator to extend with
-	* @returns A new ObjectValidator with merged schema and original configuration
-	*
-	* @example
-	* ```ts
-	* // Extend with plain schema
-	* const baseUser = v.object({
-	*   name: v.string().required(),
-	*   email: v.string().email().required()
-	* }).allowUnknown();
-	*
-	* const adminUser = baseUser.extend({
-	*   role: v.string().in(['admin', 'superadmin']).required()
-	* });
-	* // adminUser has: name, email, role
-	* // adminUser keeps: allowUnknown() from base ✅
-	*
-	* // Extend with ObjectValidator (only schema is used)
-	* const auditFields = v.object({
-	*   createdAt: v.date().required(),
-	*   updatedAt: v.date().required()
-	* }).stripUnknown(); // This config is ignored!
-	*
-	* const fullUser = baseUser.extend(auditFields);
-	* // fullUser has: name, email, createdAt, updatedAt
-	* // fullUser keeps: allowUnknown() from base (NOT stripUnknown from auditFields) ✅
-	*
-	* // Chain multiple extends
-	* const complexSchema = baseUser
-	*   .extend(auditFields)
-	*   .extend({ metadata: v.object({}) });
-	* ```
-	*/
-	extend(schemaOrValidator) {
-		const extended = this.clone();
-		const schemaToAdd = schemaOrValidator instanceof ObjectValidator ? schemaOrValidator.schema : schemaOrValidator;
-		for (const [key, validator] of Object.entries(schemaToAdd)) extended.schema[key] = validator.clone();
-		return extended;
-	}
-	/**
-	* Merge with another ObjectValidator
-	* Clones current validator, merges schemas, and **overrides configuration** with other validator's config
-	*
-	* Unlike extend(), merge() combines both schemas AND configurations.
-	* The other validator's configuration (allowUnknown, stripUnknown, etc.) takes precedence.
-	*
-	* @param validator - Another ObjectValidator to merge with
-	* @returns A new ObjectValidator with merged schema and configuration
-	*
-	* @example
-	* ```ts
-	* const baseUser = v.object({
-	*   name: v.string().required()
-	* }).allowUnknown();
-	*
-	* const timestamps = v.object({
-	*   createdAt: v.date().required(),
-	*   updatedAt: v.date().required()
-	* }).stripUnknown();
-	*
-	* const merged = baseUser.merge(timestamps);
-	* // merged has: name, createdAt, updatedAt
-	* // merged config: stripUnknown() from timestamps (overrides allowUnknown) ✅
-	*
-	* // Chain multiple merges
-	* const full = baseUser.merge(timestamps).merge(softDeleteSchema);
-	* ```
-	*/
-	merge(validator) {
-		const merged = this.clone();
-		for (const [key, schemaValidator] of Object.entries(validator.schema)) merged.schema[key] = schemaValidator.clone();
-		merged.shouldAllowUnknown = validator.shouldAllowUnknown;
-		merged.allowedKeys = [...merged.allowedKeys, ...validator.allowedKeys];
-		merged.rules.push(...validator.rules);
-		merged.mutators.push(...validator.mutators);
-		merged.dataTransformers.push(...validator.dataTransformers);
-		merged.attributesText = {
-			...merged.attributesText,
-			...validator.attributesText
-		};
-		merged.translatedAttributes = {
-			...merged.translatedAttributes,
-			...validator.translatedAttributes
-		};
-		return merged;
-	}
-	/**
-	* Create a new schema with only the specified fields
-	* Clones the current validator and keeps only the selected fields
-	* **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
-	*
-	* @param keys - Field names to keep in the schema
-	* @returns A new ObjectValidator with only the picked fields
-	*
-	* @example
-	* ```ts
-	* const fullUser = v.object({
-	*   id: v.int().required(),
-	*   name: v.string().required(),
-	*   email: v.string().email().required(),
-	*   password: v.string().required(),
-	*   role: v.string()
-	* }).allowUnknown();
-	*
-	* // For login - only need email and password
-	* const loginSchema = fullUser.pick('email', 'password');
-	* // loginSchema has: { email, password }
-	* // loginSchema keeps: allowUnknown() ✅
-	*
-	* // For public profile
-	* const publicSchema = fullUser.pick('id', 'name', 'role');
-	* // publicSchema has: { id, name, role }
-	* ```
-	*/
-	pick(...keys) {
-		const picked = this.clone();
-		const newSchema = {};
-		for (const key of keys) if (key in picked.schema) newSchema[key] = picked.schema[key];
-		picked.schema = newSchema;
-		return picked;
-	}
-	/**
-	* Mark all or the given schema fields as optional
-	*/
-	partial(...keys) {
-		const validationSchema = this.clone();
-		if (keys.length === 0) keys = Object.keys(validationSchema.schema);
-		for (const [key, validator] of Object.entries(validationSchema.schema)) if (keys.length === 0 || keys.includes(key)) validationSchema.schema[key] = validator.optional();
-		return validationSchema;
-	}
-	/**
-	* Make the all or the given fields as required
-	*/
-	requiredFields(...keys) {
-		const validationSchema = this.clone();
-		if (keys.length === 0) keys = Object.keys(validationSchema.schema);
-		for (const [key, validator] of Object.entries(validationSchema.schema)) if (keys.length === 0 || keys.includes(key)) validationSchema.schema[key] = validator.required();
-		return validationSchema;
-	}
-	/**
-	* Create a new schema excluding the specified fields
-	* Clones the current validator and removes the specified fields
-	* **Preserves all configuration** (allowUnknown, stripUnknown, etc.)
-	*
-	* @param keys - Field names to exclude from the schema
-	* @returns A new ObjectValidator without the excluded fields
-	*
-	* @example
-	* ```ts
-	* const fullUser = v.object({
-	*   id: v.int().required(),
-	*   name: v.string().required(),
-	*   email: v.string().email().required(),
-	*   password: v.string().required(),
-	*   role: v.string()
-	* }).allowUnknown();
-	*
-	* // For updates - exclude id
-	* const updateSchema = fullUser.without('id');
-	* // updateSchema has: { name, email, password, role }
-	* // updateSchema keeps: allowUnknown() ✅
-	*
-	* // For public API - exclude sensitive fields
-	* const publicSchema = fullUser.without('password', 'role');
-	* // publicSchema has: { id, name, email }
-	*
-	* // Combine with other methods
-	* const patchSchema = fullUser.without('id', 'password');
-	* // patchSchema has: { name, email, role }
-	* ```
-	*/
-	without(...keys) {
-		const filtered = this.clone();
-		const newSchema = {};
-		for (const key in filtered.schema) if (!keys.includes(key)) newSchema[key] = filtered.schema[key];
-		filtered.schema = newSchema;
-		return filtered;
-	}
-	/** Mutate the data */
-	mutate(data, context) {
-		if (!isPlainObject(data)) return data;
-		return super.mutate({ ...data }, context);
-	}
-	/** Validate the data */
-	async validate(data, context = { path: "" }) {
-		context.schema = this.schema;
-		const mutatedData = await this.mutate(data, context);
-		if (this.shouldAllowUnknown === false && !this.hasUnknownKeyRule) {
-			this.hasUnknownKeyRule = true;
-			const rule = this.addMutableRule(unknownKeyRule, void 0, {
-				allowedKeys: this.allowedKeys,
-				schema: this.schema
-			});
-			this.setRuleAttributesList(rule);
-		}
-		const result = await super.validate(mutatedData, context);
-		if (result.isValid === false) return result;
-		if (mutatedData === void 0 || mutatedData === null) return result;
-		const errors = [];
-		const validatedData = {};
-		const fieldErrors = [];
-		const validationPromises = Object.entries(this.schema).filter(([, validator]) => !this.isComputedValidator(validator)).map(async ([key, validator], index) => {
-			const isPresent = mutatedData?.[key] !== void 0;
-			const value = isPresent ? mutatedData[key] : validator.getDefaultValue();
-			const childContext = {
-				...context,
-				parent: mutatedData,
-				value,
-				key,
-				path: setKeyPath(context.path, key),
-				valueIsDefault: !isPresent && value !== void 0
-			};
-			const childResult = await validator.validate(value, childContext);
-			if (childResult.data !== void 0 && !validator.isOmitted()) validatedData[key] = childResult.data;
-			if (childResult.isValid === false) fieldErrors[index] = childResult.errors;
-		});
-		await Promise.all(validationPromises);
-		for (const childErrors of fieldErrors) if (childErrors) errors.push(...childErrors);
-		if (errors.length > 0) return {
-			isValid: false,
-			errors,
-			data: void 0
-		};
-		const computedFields = this.getComputedFields();
-		const computedErrors = [];
-		const computedPromises = Object.entries(computedFields).map(async ([key, validator], index) => {
-			const childContext = {
-				...context,
-				parent: validatedData,
-				value: void 0
-			};
-			const childResult = await validator.validate(validatedData, childContext);
-			if (childResult.data !== void 0 && !validator.isOmitted()) validatedData[key] = childResult.data;
-			if (childResult.isValid === false) computedErrors[index] = childResult.errors;
-		});
-		await Promise.all(computedPromises);
-		for (const childErrors of computedErrors) if (childErrors) errors.push(...childErrors);
-		if (errors.length > 0) return {
-			isValid: false,
-			errors,
-			data: void 0
-		};
-		const orderedData = {};
-		for (const key of Object.keys(this.schema)) if (key in validatedData) orderedData[key] = validatedData[key];
-		const cleanedData = removeUndefinedValues(orderedData);
-		const transformedData = await this.startTransformationPipeline(cleanedData, context);
-		return {
-			isValid: true,
-			errors: [],
-			data: this.shouldAllowUnknown === false ? transformedData : {
-				...transformedData,
-				...except(mutatedData, Object.keys(this.schema))
-			}
-		};
-	}
-	/**
-	* Check if a validator is a computed or managed field
-	* ManagedValidator extends ComputedValidator, so instanceof catches both
-	*/
-	isComputedValidator(validator) {
-		return validator instanceof ComputedValidator;
-	}
-	/**
-	* Get all computed/managed fields from the schema
-	*/
-	getComputedFields() {
-		const computed = {};
-		for (const [key, validator] of Object.entries(this.schema)) if (validator instanceof ComputedValidator) computed[key] = validator;
-		return computed;
-	}
-	/**
-	* @inheritdoc
-	*
-	* Recursively generates JSON Schema for all input fields in the schema.
-	* Computed/managed fields are skipped — they have no input representation.
-	*
-	* **Standard targets** (`draft-2020-12`, `draft-07`, `openapi-3.0`):
-	* - Fields marked `.optional()` are excluded from `required`.
-	*
-	* **`openai-strict` target** (OpenAI Structured Outputs):
-	* - ALL fields appear in `required` — OpenAI rejects schemas with optional fields.
-	* - Optional fields are instead expressed as nullable types:
-	*   `{ type: ["string", "null"] }` so the model can output `null` for them.
-	* - Recursively applies `openai-strict` to all nested objects.
-	*
-	* @example
-	* ```ts
-	* v.object({
-	*   name: v.string().required(),
-	*   age: v.int().optional(),
-	* }).toJsonSchema("draft-2020-12")
-	* // → { type: "object",
-	* //     properties: { name: { type: "string" }, age: { type: "integer" } },
-	* //     required: ["name"], additionalProperties: false }
-	*
-	* v.object({
-	*   name: v.string().required(),
-	*   age: v.int().optional(),
-	* }).toJsonSchema("openai-strict")
-	* // → { type: "object",
-	* //     properties: { name: { type: "string" }, age: { type: ["integer", "null"] } },
-	* //     required: ["name", "age"],   ← all fields
-	* //     additionalProperties: false }
-	* ```
-	*/
-	toJsonSchema(target = "draft-2020-12") {
-		const properties = {};
-		const required = [];
-		const isOpenAIStrict = target === "openai-strict";
-		for (const [key, validator] of Object.entries(this.schema)) {
-			if (validator instanceof ComputedValidator) continue;
-			let fieldSchema = validator.toJsonSchema(target);
-			if (isOpenAIStrict) {
-				if (validator.isOptional) fieldSchema = wrapNullableStrict(fieldSchema);
-				required.push(key);
-			} else if (!validator.isOptional) required.push(key);
-			properties[key] = fieldSchema;
-		}
-		const schema = {
-			type: "object",
-			properties
-		};
-		if (required.length > 0) schema.required = required;
-		if (!this.shouldAllowUnknown) schema.additionalProperties = false;
-		if (this.isNullable) applyNullable(schema, target);
-		return schema;
-	}
-};
-/** Recursively remove undefined values from an object */
-function removeUndefinedValues(obj, visited = /* @__PURE__ */ new WeakMap()) {
-	if (obj === null) return obj;
-	if (Array.isArray(obj)) return obj.map((item) => removeUndefinedValues(item, visited));
-	if (!isPlainObject(obj)) return obj;
-	if (visited.has(obj)) return visited.get(obj);
-	const result = {};
-	visited.set(obj, result);
-	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = removeUndefinedValues(value, visited);
-	return result;
-}
-
-//#endregion
-export { ObjectValidator };
-//# sourceMappingURL=object-validator.mjs.map

package/esm/packages/seal/src/validators/object-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"object-validator.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/validators/object-validator.ts"],"sourcesContent":["import { except } from \"@mongez/reinforcements\";\nimport { isPlainObject } from \"@mongez/supportive-is\";\nimport { setKeyPath } from \"../helpers/path-helpers\";\nimport { objectTrimMutator, stripUnknownMutator } from \"../mutators/object-mutators\";\nimport { objectRule } from \"../rules/common/type-rules\";\nimport { unknownKeyRule } from \"../rules/common/unknown-key\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { applyNullable, wrapNullableStrict } from \"../standard-schema/json-schema\";\nimport type { Schema, SchemaContext, ValidationResult } from \"../types\";\nimport type { InferInputObjectShape, InferOutputObjectShape } from \"../types/inference-types\";\nimport { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator } from \"./computed-validator\";\n\n/**\n * Object validator class with generic schema type for proper type inference.\n *\n * Threads two distinct inferred shapes into `BaseValidator`'s `TInput`/`TOutput`:\n *\n * - `TInput`  = `InferInputObjectShape<TSchema>`  — what `~standard.validate()`\n *               accepts (caller's pre-validation payload; defaults/catches make\n *               keys optional)\n * - `TOutput` = `InferOutputObjectShape<TSchema>` — what `~standard.validate()`\n *               returns on success (post-default, post-catch shape; guaranteed\n *               keys are required)\n *\n * Both helpers are used directly (not the full `Infer.*` walker) to avoid a\n * recursive class-base evaluation that would otherwise occur when the\n * brand-aware widening tries to inspect the class type.\n */\nexport class ObjectValidator<TSchema extends Schema = Schema> extends BaseValidator<\n  InferInputObjectShape<TSchema>,\n  InferOutputObjectShape<TSchema>\n> {\n  protected shouldAllowUnknown = false;\n  protected allowedKeys: string[] = [];\n  protected hasUnknownKeyRule = false;\n\n  public constructor(\n    public schema: TSchema,\n    errorMessage?: string,\n  ) {\n    super();\n    this.addMutableRule(objectRule, errorMessage);\n  }\n\n  /**\n   * Check if value is an object type (plain object, not array or date)\n   */\n  public matchesType(value: any): boolean {\n    return isPlainObject(value);\n  }\n\n  /** Strip unknown keys from the data */\n  public stripUnknown() {\n    const validator = this.instance;\n    return validator.addMutator(stripUnknownMutator, {\n      get allowedKeys() {\n        return validator.allowedKeys;\n      },\n    });\n  }\n\n  /** Add list of allowed keys that could be in the data but not necessarily validated */\n  public allow(...keys: string[]) {\n    const validator = this.instance;\n    validator.allowedKeys.push(...keys);\n    return validator;\n  }\n\n  /** Trim values of the object properties */\n  public trim(recursive = true) {\n    const validator = this.instance;\n    return validator.addMutator(objectTrimMutator, { recursive });\n  }\n\n  /** Whether to allow unknown properties\n   * Please note it will allow only unknown direct children keys, not nested children keys\n   */\n  public allowUnknown(allow = true) {\n    const validator = this.instance;\n    validator.shouldAllowUnknown = allow;\n    return validator;\n  }\n\n  /**\n   * Create a copy of this object validator with the same configuration\n   * Copies schema, rules, mutators, transformers, and object-specific settings\n   *\n   * @returns A new ObjectValidator instance with copied configuration\n   *\n   * @example\n   * ```ts\n   * const baseUser = v.object({ name: v.string() }).allowUnknown();\n   * const userCopy = baseUser.clone();\n   * // userCopy has the same schema and allowUnknown setting\n   * ```\n   */\n  public override clone(keys?: string[]): this {\n    // Get cloned instance with all BaseValidator properties\n    const cloned = super.clone();\n\n    // Clone schema with deep copy of validators\n    const newSchema = {} as TSchema;\n    for (const [key, validator] of Object.entries(this.schema)) {\n      if (keys && !keys.includes(key)) continue;\n      (newSchema as Schema)[key] = validator.clone();\n    }\n\n    cloned.schema = newSchema;\n\n    // Add ObjectValidator-specific properties\n    cloned.shouldAllowUnknown = this.shouldAllowUnknown;\n    cloned.allowedKeys = [...this.allowedKeys];\n    // NOTE: hasUnknownKeyRule is intentionally NOT copied.\n    // Each clone must add its own unknownKeyRule on first validate()\n    // so it holds references to its own schema/allowedKeys, not the original's.\n\n    return cloned;\n  }\n\n  /**\n   * Extend this schema with additional fields\n   * Clones the current validator and adds new fields to the schema\n   * **Keeps original configuration** (allowUnknown, stripUnknown, etc.)\n   *\n   * If an ObjectValidator is provided, only its schema is used - its configuration is ignored.\n   * This is useful for creating reusable field collections that can be added to different schemas.\n   *\n   * @param schemaOrValidator - Plain schema object or ObjectValidator to extend with\n   * @returns A new ObjectValidator with merged schema and original configuration\n   *\n   * @example\n   * ```ts\n   * // Extend with plain schema\n   * const baseUser = v.object({\n   *   name: v.string().required(),\n   *   email: v.string().email().required()\n   * }).allowUnknown();\n   *\n   * const adminUser = baseUser.extend({\n   *   role: v.string().in(['admin', 'superadmin']).required()\n   * });\n   * // adminUser has: name, email, role\n   * // adminUser keeps: allowUnknown() from base ✅\n   *\n   * // Extend with ObjectValidator (only schema is used)\n   * const auditFields = v.object({\n   *   createdAt: v.date().required(),\n   *   updatedAt: v.date().required()\n   * }).stripUnknown(); // This config is ignored!\n   *\n   * const fullUser = baseUser.extend(auditFields);\n   * // fullUser has: name, email, createdAt, updatedAt\n   * // fullUser keeps: allowUnknown() from base (NOT stripUnknown from auditFields) ✅\n   *\n   * // Chain multiple extends\n   * const complexSchema = baseUser\n   *   .extend(auditFields)\n   *   .extend({ metadata: v.object({}) });\n   * ```\n   */\n  public extend<TExtension extends Schema>(\n    schemaOrValidator: TExtension | ObjectValidator<TExtension>,\n  ): ObjectValidator<TSchema & TExtension> {\n    // Clone current validator to preserve original\n    const extended = this.clone() as any;\n\n    // Extract schema from parameter\n    const schemaToAdd =\n      schemaOrValidator instanceof ObjectValidator ? schemaOrValidator.schema : schemaOrValidator;\n\n    // Merge schemas with cloned validators (later fields override earlier ones)\n    for (const [key, validator] of Object.entries(schemaToAdd)) {\n      (extended.schema as Schema)[key] = validator.clone();\n    }\n\n    return extended as ObjectValidator<TSchema & TExtension>;\n  }\n\n  /**\n   * Merge with another ObjectValidator\n   * Clones current validator, merges schemas, and **overrides configuration** with other validator's config\n   *\n   * Unlike extend(), merge() combines both schemas AND configurations.\n   * The other validator's configuration (allowUnknown, stripUnknown, etc.) takes precedence.\n   *\n   * @param validator - Another ObjectValidator to merge with\n   * @returns A new ObjectValidator with merged schema and configuration\n   *\n   * @example\n   * ```ts\n   * const baseUser = v.object({\n   *   name: v.string().required()\n   * }).allowUnknown();\n   *\n   * const timestamps = v.object({\n   *   createdAt: v.date().required(),\n   *   updatedAt: v.date().required()\n   * }).stripUnknown();\n   *\n   * const merged = baseUser.merge(timestamps);\n   * // merged has: name, createdAt, updatedAt\n   * // merged config: stripUnknown() from timestamps (overrides allowUnknown) ✅\n   *\n   * // Chain multiple merges\n   * const full = baseUser.merge(timestamps).merge(softDeleteSchema);\n   * ```\n   */\n  public merge<TMerge extends Schema>(\n    validator: ObjectValidator<TMerge>,\n  ): ObjectValidator<TSchema & TMerge> {\n    // Clone current validator\n    const merged = this.clone() as any;\n\n    // Merge schemas with cloned validators (later fields override earlier ones)\n    for (const [key, schemaValidator] of Object.entries(validator.schema)) {\n      (merged.schema as Schema)[key] = schemaValidator.clone();\n    }\n\n    // Override configuration with other validator's config\n    merged.shouldAllowUnknown = validator.shouldAllowUnknown;\n    merged.allowedKeys = [...merged.allowedKeys, ...validator.allowedKeys];\n\n    // Append rules, mutators, transformers from other validator\n    merged.rules.push(...validator.rules);\n    merged.mutators.push(...validator.mutators);\n    merged.dataTransformers.push(...validator.dataTransformers);\n\n    // Merge attributes text (later wins)\n    merged.attributesText = {\n      ...merged.attributesText,\n      ...validator.attributesText,\n    };\n\n    merged.translatedAttributes = {\n      ...merged.translatedAttributes,\n      ...validator.translatedAttributes,\n    };\n\n    return merged as ObjectValidator<TSchema & TMerge>;\n  }\n\n  /**\n   * Create a new schema with only the specified fields\n   * Clones the current validator and keeps only the selected fields\n   * **Preserves all configuration** (allowUnknown, stripUnknown, etc.)\n   *\n   * @param keys - Field names to keep in the schema\n   * @returns A new ObjectValidator with only the picked fields\n   *\n   * @example\n   * ```ts\n   * const fullUser = v.object({\n   *   id: v.int().required(),\n   *   name: v.string().required(),\n   *   email: v.string().email().required(),\n   *   password: v.string().required(),\n   *   role: v.string()\n   * }).allowUnknown();\n   *\n   * // For login - only need email and password\n   * const loginSchema = fullUser.pick('email', 'password');\n   * // loginSchema has: { email, password }\n   * // loginSchema keeps: allowUnknown() ✅\n   *\n   * // For public profile\n   * const publicSchema = fullUser.pick('id', 'name', 'role');\n   * // publicSchema has: { id, name, role }\n   * ```\n   */\n  public pick<K extends keyof TSchema>(...keys: K[]): ObjectValidator<Pick<TSchema, K>> {\n    // Clone current validator\n    const picked = this.clone() as any;\n\n    // Create new schema with only picked keys\n    const newSchema = {} as Pick<TSchema, K>;\n    for (const key of keys) {\n      if (key in picked.schema) {\n        (newSchema as any)[key] = picked.schema[key];\n      }\n    }\n\n    picked.schema = newSchema;\n\n    return picked as ObjectValidator<Pick<TSchema, K>>;\n  }\n\n  /**\n   * Mark all or the given schema fields as optional\n   */\n  public partial<K extends keyof TSchema>(...keys: K[]) {\n    const validationSchema = this.clone();\n\n    if (keys.length === 0) {\n      keys = Object.keys(validationSchema.schema) as K[];\n    }\n\n    for (const [key, validator] of Object.entries(validationSchema.schema)) {\n      if (keys.length === 0 || keys.includes(key as K)) {\n        (validationSchema.schema as Schema)[key] = validator.optional();\n      }\n    }\n\n    return validationSchema;\n  }\n\n  /**\n   * Make the all or the given fields as required\n   */\n  public requiredFields<K extends keyof TSchema>(...keys: K[]) {\n    const validationSchema = this.clone();\n\n    if (keys.length === 0) {\n      keys = Object.keys(validationSchema.schema) as K[];\n    }\n\n    for (const [key, validator] of Object.entries(validationSchema.schema)) {\n      if (keys.length === 0 || keys.includes(key as K)) {\n        (validationSchema.schema as Schema)[key] = validator.required();\n      }\n    }\n\n    return validationSchema;\n  }\n\n  /**\n   * Create a new schema excluding the specified fields\n   * Clones the current validator and removes the specified fields\n   * **Preserves all configuration** (allowUnknown, stripUnknown, etc.)\n   *\n   * @param keys - Field names to exclude from the schema\n   * @returns A new ObjectValidator without the excluded fields\n   *\n   * @example\n   * ```ts\n   * const fullUser = v.object({\n   *   id: v.int().required(),\n   *   name: v.string().required(),\n   *   email: v.string().email().required(),\n   *   password: v.string().required(),\n   *   role: v.string()\n   * }).allowUnknown();\n   *\n   * // For updates - exclude id\n   * const updateSchema = fullUser.without('id');\n   * // updateSchema has: { name, email, password, role }\n   * // updateSchema keeps: allowUnknown() ✅\n   *\n   * // For public API - exclude sensitive fields\n   * const publicSchema = fullUser.without('password', 'role');\n   * // publicSchema has: { id, name, email }\n   *\n   * // Combine with other methods\n   * const patchSchema = fullUser.without('id', 'password');\n   * // patchSchema has: { name, email, role }\n   * ```\n   */\n  public without<K extends keyof TSchema>(...keys: K[]): ObjectValidator<Omit<TSchema, K>> {\n    // Clone current validator\n    const filtered = this.clone() as any;\n\n    // Create new schema excluding specified keys\n    const newSchema = {} as Omit<TSchema, K>;\n    for (const key in filtered.schema) {\n      if (!keys.includes(key as any)) {\n        (newSchema as any)[key] = filtered.schema[key];\n      }\n    }\n\n    filtered.schema = newSchema;\n\n    return filtered as ObjectValidator<Omit<TSchema, K>>;\n  }\n\n  /** Mutate the data */\n  public mutate(data: any, context: SchemaContext) {\n    if (!isPlainObject(data)) return data;\n    return super.mutate({ ...data }, context);\n  }\n\n  /** Validate the data */\n  public async validate(\n    data: any,\n    context: SchemaContext = { path: \"\" } as SchemaContext,\n  ): Promise<ValidationResult> {\n    context.schema = this.schema;\n    const mutatedData = await this.mutate(data, context);\n\n    // Check for unknown properties\n    if (this.shouldAllowUnknown === false && !this.hasUnknownKeyRule) {\n      this.hasUnknownKeyRule = true;\n      const rule = this.addMutableRule(unknownKeyRule, undefined, {\n        allowedKeys: this.allowedKeys,\n        schema: this.schema,\n      });\n\n      this.setRuleAttributesList(rule);\n    }\n\n    const result = await super.validate(mutatedData, context);\n\n    if (result.isValid === false) return result;\n\n    // Absent (no default) or null (nullable) inputs short-circuit here —\n    // BaseValidator.validate already resolved the outcome, so recursing into\n    // the shape below would wrongly re-run required checks against `undefined`.\n    if (mutatedData === undefined || mutatedData === null) return result;\n\n    // ═══════════════════════════════════════════════════════════\n    // PHASE 1: Validate user input fields (skip computed/managed)\n    // ═══════════════════════════════════════════════════════════\n    const errors: ValidationResult[\"errors\"] = [];\n    const validatedData: any = {};\n\n    // Child validators settle in completion order, so errors are collected per\n    // field and flattened in declared schema order for deterministic output.\n    const fieldErrors: Array<ValidationResult[\"errors\"]> = [];\n\n    const userInputEntries = Object.entries(this.schema).filter(\n      ([, validator]) => !this.isComputedValidator(validator),\n    );\n\n    const validationPromises = userInputEntries.map(async ([key, validator], index) => {\n      const isPresent = mutatedData?.[key] !== undefined;\n      const value = isPresent ? mutatedData[key] : validator.getDefaultValue();\n\n      const childContext: SchemaContext = {\n        ...context,\n        parent: mutatedData,\n        value,\n        key,\n        path: setKeyPath(context.path, key),\n        valueIsDefault: !isPresent && value !== undefined,\n      };\n\n      const childResult = await validator.validate(value, childContext);\n\n      // Only include in validated data if not omitted\n      if (childResult.data !== undefined && !validator.isOmitted()) {\n        validatedData[key] = childResult.data;\n      }\n\n      if (childResult.isValid === false) {\n        fieldErrors[index] = childResult.errors;\n      }\n    });\n\n    await Promise.all(validationPromises);\n\n    for (const childErrors of fieldErrors) {\n      if (childErrors) {\n        errors.push(...childErrors);\n      }\n    }\n\n    // If Phase 1 failed, return early\n    if (errors.length > 0) {\n      return {\n        isValid: false,\n        errors,\n        data: undefined,\n      };\n    }\n\n    // ═══════════════════════════════════════════════════════════\n    // PHASE 2: Execute computed/managed fields with validated data\n    // ═══════════════════════════════════════════════════════════\n    const computedFields = this.getComputedFields();\n\n    const computedErrors: Array<ValidationResult[\"errors\"]> = [];\n\n    const computedPromises = Object.entries(computedFields).map(async ([key, validator], index) => {\n      const childContext: SchemaContext = {\n        ...context,\n        parent: validatedData,\n        value: undefined, // Computed fields don't have input value\n      };\n\n      // Execute computed callback with validated data\n      const childResult = await validator.validate(validatedData, childContext);\n\n      // Only include in final data if not omitted\n      if (childResult.data !== undefined && !validator.isOmitted()) {\n        validatedData[key] = childResult.data;\n      }\n\n      if (childResult.isValid === false) {\n        computedErrors[index] = childResult.errors;\n      }\n    });\n\n    await Promise.all(computedPromises);\n\n    for (const childErrors of computedErrors) {\n      if (childErrors) {\n        errors.push(...childErrors);\n      }\n    }\n\n    // If Phase 2 failed, return early\n    if (errors.length > 0) {\n      return {\n        isValid: false,\n        errors,\n        data: undefined,\n      };\n    }\n\n    // Fields were assigned in the order their validators finished; re-emit\n    // them in declared schema order so the output shape is deterministic.\n    const orderedData: any = {};\n\n    for (const key of Object.keys(this.schema)) {\n      if (key in validatedData) {\n        orderedData[key] = validatedData[key];\n      }\n    }\n\n    // Remove undefined values\n    const cleanedData = removeUndefinedValues(orderedData);\n\n    const transformedData = await this.startTransformationPipeline(cleanedData, context);\n\n    const output =\n      this.shouldAllowUnknown === false\n        ? transformedData\n        : {\n            ...transformedData,\n            ...except(mutatedData, Object.keys(this.schema)),\n          };\n\n    return {\n      isValid: true,\n      errors: [],\n      data: output,\n    };\n  }\n\n  /**\n   * Check if a validator is a computed or managed field\n   * ManagedValidator extends ComputedValidator, so instanceof catches both\n   */\n  private isComputedValidator(validator: BaseValidator): boolean {\n    return validator instanceof ComputedValidator;\n  }\n\n  /**\n   * Get all computed/managed fields from the schema\n   */\n  private getComputedFields(): Record<string, ComputedValidator> {\n    const computed: Record<string, ComputedValidator> = {};\n\n    for (const [key, validator] of Object.entries(this.schema)) {\n      if (validator instanceof ComputedValidator) {\n        computed[key] = validator;\n      }\n    }\n\n    return computed;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Recursively generates JSON Schema for all input fields in the schema.\n   * Computed/managed fields are skipped — they have no input representation.\n   *\n   * **Standard targets** (`draft-2020-12`, `draft-07`, `openapi-3.0`):\n   * - Fields marked `.optional()` are excluded from `required`.\n   *\n   * **`openai-strict` target** (OpenAI Structured Outputs):\n   * - ALL fields appear in `required` — OpenAI rejects schemas with optional fields.\n   * - Optional fields are instead expressed as nullable types:\n   *   `{ type: [\"string\", \"null\"] }` so the model can output `null` for them.\n   * - Recursively applies `openai-strict` to all nested objects.\n   *\n   * @example\n   * ```ts\n   * v.object({\n   *   name: v.string().required(),\n   *   age: v.int().optional(),\n   * }).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"object\",\n   * //     properties: { name: { type: \"string\" }, age: { type: \"integer\" } },\n   * //     required: [\"name\"], additionalProperties: false }\n   *\n   * v.object({\n   *   name: v.string().required(),\n   *   age: v.int().optional(),\n   * }).toJsonSchema(\"openai-strict\")\n   * // → { type: \"object\",\n   * //     properties: { name: { type: \"string\" }, age: { type: [\"integer\", \"null\"] } },\n   * //     required: [\"name\", \"age\"],   ← all fields\n   * //     additionalProperties: false }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const properties: Record<string, JsonSchemaResult> = {};\n    const required: string[] = [];\n    const isOpenAIStrict = target === \"openai-strict\";\n\n    for (const [key, validator] of Object.entries(this.schema)) {\n      // Skip computed/managed — runtime-only, no input schema\n      if (validator instanceof ComputedValidator) continue;\n\n      let fieldSchema = validator.toJsonSchema(target);\n\n      if (isOpenAIStrict) {\n        // OpenAI strict: every field must be in required.\n        // Optional fields are expressed as nullable rather than absent.\n        if (validator.isOptional) {\n          fieldSchema = wrapNullableStrict(fieldSchema);\n        }\n        required.push(key);\n      } else {\n        // Standard JSON Schema: only non-optional fields go in required\n        if (!validator.isOptional) {\n          required.push(key);\n        }\n      }\n\n      properties[key] = fieldSchema;\n    }\n\n    const schema: JsonSchemaResult = { type: \"object\", properties };\n\n    if (required.length > 0) schema.required = required;\n    if (!this.shouldAllowUnknown) schema.additionalProperties = false;\n    if (this.isNullable) applyNullable(schema, target);\n\n    return schema;\n  }\n}\n\n/** Recursively remove undefined values from an object */\nfunction removeUndefinedValues(obj: any, visited = new WeakMap<object, any>()): any {\n  // Handle primitives and null\n  if (obj === null) {\n    return obj;\n  }\n\n  // Handle arrays\n  if (Array.isArray(obj)) {\n    return obj.map((item) => removeUndefinedValues(item, visited));\n  }\n\n  // Skip non-plain objects (class instances, Dates, Buffers, etc.)\n  if (!isPlainObject(obj)) {\n    return obj;\n  }\n\n  // Handle circular references - return already processed result\n  if (visited.has(obj)) {\n    return visited.get(obj);\n  }\n\n  // Process plain objects\n  const result: any = {};\n  visited.set(obj, result); // Mark as processing BEFORE recursion\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (value !== undefined) {\n      result[key] = removeUndefinedValues(value, visited);\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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"}

package/esm/packages/seal/src/validators/primitive-validator.mjs

@@ -1,88 +0,0 @@
-import { BaseValidator } from "./base-validator.mjs";
-import { allowedValuesRule, enumRule, inRule, notAllowedValuesRule } from "../rules/common/enum.mjs";
-
-//#region ../../packages/seal/src/validators/primitive-validator.ts
-/**
-* Abstract base validator for primitive-typed fields (string, number, boolean).
-*
-* Provides value-membership rules that are meaningful for any single primitive value
-* but not for complex structures (object, array).
-*
-* Do NOT expose this on the `v` factory — it is an inheritance-only base class.
-*
-* Hierarchy:
-*   BaseValidator
-*     └── PrimitiveValidator    ← enum, in, oneOf, allowsOnly, forbids, notIn
-*           ├── StringValidator
-*           ├── NumberValidator
-*           │     └── FloatValidator
-*           ├── BooleanValidator
-*           └── ScalarValidator  (extends PrimitiveValidator, adds asNumber/asString/accepted/declined)
-*
-* @example
-* class MyValidator extends PrimitiveValidator {
-*   // inherits: in(), forbids(), enum(), oneOf(), allowsOnly(), notIn()
-* }
-*/
-var PrimitiveValidator = class extends BaseValidator {
-	/**
-	* Value must be one of the enum's values
-	*
-	* @example
-	* v.string().enum(Direction) // Direction is a TS enum
-	*/
-	enum(values, errorMessage) {
-		return this.addRule(enumRule, errorMessage, { enum: Object.values(values) });
-	}
-	/**
-	* Value must be one of the given values
-	*
-	* @example
-	* v.string().in(["admin", "user", "guest"])
-	* v.number().in([1, 2, 3])
-	*/
-	in(values, errorMessage) {
-		return this.addRule(inRule, errorMessage, { values });
-	}
-	/**
-	* Alias for `in()`
-	*
-	* @example
-	* v.string().oneOf(["active", "inactive"])
-	*/
-	oneOf(values, errorMessage) {
-		return this.in(values, errorMessage);
-	}
-	/**
-	* Value must be one of the allowed values (stricter variant)
-	*
-	* @example
-	* v.string().allowsOnly(["yes", "no"])
-	*/
-	allowsOnly(values, errorMessage) {
-		return this.addRule(allowedValuesRule, errorMessage, { allowedValues: values });
-	}
-	/**
-	* Value must NOT be one of the given values
-	*
-	* @example
-	* v.string().forbids(["banned", "blacklisted"])
-	* v.number().forbids([0, -1])
-	*/
-	forbids(values, errorMessage) {
-		return this.addRule(notAllowedValuesRule, errorMessage, { notAllowedValues: values });
-	}
-	/**
-	* Alias for `forbids()`
-	*
-	* @example
-	* v.string().notIn(["OK", "NOT OK"])
-	*/
-	notIn(values, errorMessage) {
-		return this.forbids(values, errorMessage);
-	}
-};
-
-//#endregion
-export { PrimitiveValidator };
-//# sourceMappingURL=primitive-validator.mjs.map

package/esm/packages/seal/src/validators/primitive-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"primitive-validator.mjs","names":[],"sources":["../../../../../../../../../../../packages/seal/src/validators/primitive-validator.ts"],"sourcesContent":["import { allowedValuesRule, enumRule, inRule, notAllowedValuesRule } from \"../rules/common/enum\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Abstract base validator for primitive-typed fields (string, number, boolean).\n *\n * Provides value-membership rules that are meaningful for any single primitive value\n * but not for complex structures (object, array).\n *\n * Do NOT expose this on the `v` factory — it is an inheritance-only base class.\n *\n * Hierarchy:\n *   BaseValidator\n *     └── PrimitiveValidator    ← enum, in, oneOf, allowsOnly, forbids, notIn\n *           ├── StringValidator\n *           ├── NumberValidator\n *           │     └── FloatValidator\n *           ├── BooleanValidator\n *           └── ScalarValidator  (extends PrimitiveValidator, adds asNumber/asString/accepted/declined)\n *\n * @example\n * class MyValidator extends PrimitiveValidator {\n *   // inherits: in(), forbids(), enum(), oneOf(), allowsOnly(), notIn()\n * }\n */\nexport abstract class PrimitiveValidator extends BaseValidator {\n  /**\n   * Value must be one of the enum's values\n   *\n   * @example\n   * v.string().enum(Direction) // Direction is a TS enum\n   */\n  public enum(values: any, errorMessage?: string) {\n    return this.addRule(enumRule, errorMessage, { enum: Object.values(values) });\n  }\n\n  /**\n   * Value must be one of the given values\n   *\n   * @example\n   * v.string().in([\"admin\", \"user\", \"guest\"])\n   * v.number().in([1, 2, 3])\n   */\n  public in(values: any[], errorMessage?: string) {\n    return this.addRule(inRule, errorMessage, { values });\n  }\n\n  /**\n   * Alias for `in()`\n   *\n   * @example\n   * v.string().oneOf([\"active\", \"inactive\"])\n   */\n  public oneOf(values: any[], errorMessage?: string) {\n    return this.in(values, errorMessage);\n  }\n\n  /**\n   * Value must be one of the allowed values (stricter variant)\n   *\n   * @example\n   * v.string().allowsOnly([\"yes\", \"no\"])\n   */\n  public allowsOnly(values: any[], errorMessage?: string) {\n    return this.addRule(allowedValuesRule, errorMessage, { allowedValues: values });\n  }\n\n  /**\n   * Value must NOT be one of the given values\n   *\n   * @example\n   * v.string().forbids([\"banned\", \"blacklisted\"])\n   * v.number().forbids([0, -1])\n   */\n  public forbids(values: any[], errorMessage?: string) {\n    return this.addRule(notAllowedValuesRule, errorMessage, { notAllowedValues: values });\n  }\n\n  /**\n   * Alias for `forbids()`\n   *\n   * @example\n   * v.string().notIn([\"OK\", \"NOT OK\"])\n   */\n  public notIn(values: any[], errorMessage?: string) {\n    return this.forbids(values, errorMessage);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAsB,qBAAtB,cAAiD,cAAc;;;;;;;CAO7D,AAAO,KAAK,QAAa,cAAuB;EAC9C,OAAO,KAAK,QAAQ,UAAU,cAAc,EAAE,MAAM,OAAO,OAAO,MAAM,EAAE,CAAC;CAC7E;;;;;;;;CASA,AAAO,GAAG,QAAe,cAAuB;EAC9C,OAAO,KAAK,QAAQ,QAAQ,cAAc,EAAE,OAAO,CAAC;CACtD;;;;;;;CAQA,AAAO,MAAM,QAAe,cAAuB;EACjD,OAAO,KAAK,GAAG,QAAQ,YAAY;CACrC;;;;;;;CAQA,AAAO,WAAW,QAAe,cAAuB;EACtD,OAAO,KAAK,QAAQ,mBAAmB,cAAc,EAAE,eAAe,OAAO,CAAC;CAChF;;;;;;;;CASA,AAAO,QAAQ,QAAe,cAAuB;EACnD,OAAO,KAAK,QAAQ,sBAAsB,cAAc,EAAE,kBAAkB,OAAO,CAAC;CACtF;;;;;;;CAQA,AAAO,MAAM,QAAe,cAAuB;EACjD,OAAO,KAAK,QAAQ,QAAQ,YAAY;CAC1C;AACF"}