@warlock.js/seal 5.15.0 → 5.17.0

package/cjs/object-_2YHdBxJ.cjs

@@ -0,0 +1,613 @@
+const require_required_methods = require('./required-methods-GwIEE6hP.cjs');
+let _mongez_reinforcements = require("@mongez/reinforcements");
+let _mongez_supportive_is = require("@mongez/supportive-is");
+
+//#region ../seal/src/mutators/object-mutators.ts
+/** Strip unknown keys from object */
+const stripUnknownMutator = async (value, context) => {
+	const allowedKeys = [...context?.ctx.schema ? Object.keys(context.ctx.schema) : [], ...context?.options.allowedKeys ?? []];
+	const result = {};
+	for (const key in value) if (allowedKeys.includes(key)) result[key] = value[key];
+	return result;
+};
+/** Trim all string values in object */
+const objectTrimMutator = async (value, context) => {
+	if (!(0, _mongez_supportive_is.isPlainObject)(value)) return value;
+	const result = {};
+	const recursive = context?.options.recursive ?? false;
+	for (const key in value) {
+		const item = value[key];
+		if (recursive) if (Array.isArray(item)) result[key] = await Promise.all(item.map(async (i) => typeof i === "string" ? (0, _mongez_reinforcements.trim)(i) : await objectTrimMutator(i, context)));
+		else if ((0, _mongez_supportive_is.isPlainObject)(item)) result[key] = await objectTrimMutator(item, context);
+		else result[key] = typeof item === "string" ? (0, _mongez_reinforcements.trim)(item) : item;
+		else result[key] = typeof item === "string" ? (0, _mongez_reinforcements.trim)(item) : item;
+	}
+	return result;
+};
+/** Parse JSON string */
+const jsonMutator = async (value) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+};
+
+//#endregion
+//#region ../seal/src/validators/computed-validator.ts
+/**
+* Computed field validator
+*
+* Computes a value based on other validated fields in the schema.
+* The computed value is persisted and can optionally be validated.
+*
+* @example
+* ```ts
+* // Basic computed field
+* const schema = v.object({
+*   title: v.string().required(),
+*   slug: v.computed(data => slugify(data.title)),
+* });
+*
+* // With result validation
+* const schema = v.object({
+*   title: v.string().required(),
+*   slug: v.computed(
+*     data => slugify(data.title),
+*     v.string().minLength(3)
+*   ),
+* });
+*
+* // Async computation
+* const schema = v.object({
+*   image: v.string().url(),
+*   thumbnail: v.computed(async data => {
+*     return await generateThumbnail(data.image);
+*   }),
+* });
+* ```
+*/
+var ComputedValidator = class extends require_required_methods.BaseValidator {
+	/**
+	* Create a new computed field validator
+	*
+	* @param callback - Function to compute the value from validated data
+	* @param resultValidator - Optional validator to validate the computed result
+	*/
+	constructor(callback, resultValidator) {
+		super();
+		this.callback = callback;
+		this.resultValidator = resultValidator;
+	}
+	/**
+	* Execute the callback and optionally validate the result
+	*/
+	async validate(data, context) {
+		try {
+			const result = await this.callback(data, context);
+			if (this.resultValidator) {
+				const validation = await this.resultValidator.validate(result, context);
+				if (!validation.isValid) return {
+					isValid: false,
+					errors: validation.errors,
+					data: void 0
+				};
+				return {
+					isValid: true,
+					errors: [],
+					data: validation.data
+				};
+			}
+			return {
+				isValid: true,
+				errors: [],
+				data: result
+			};
+		} catch (error) {
+			return {
+				isValid: false,
+				errors: [{
+					type: "computed",
+					error: error instanceof Error ? error.message : "Computed field callback failed",
+					input: context.path
+				}],
+				data: void 0
+			};
+		}
+	}
+	/**
+	* Clone this validator with all its configuration
+	* Critical for ObjectValidator.clone(), extend(), merge(), etc.
+	*/
+	clone() {
+		const cloned = super.clone();
+		cloned.callback = this.callback;
+		cloned.resultValidator = this.resultValidator?.clone();
+		return cloned;
+	}
+	/**
+	* Computed fields don't have a specific type to match
+	*/
+	matchesType(value) {
+		return true;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Computed fields are server-side runtime values — they have no input schema
+	* and cannot be represented in JSON Schema. Calling this method is always a
+	* programming error.
+	*
+	* @throws Error Always throws — computed/managed fields have no JSON Schema representation.
+	*/
+	toJsonSchema(_target = "draft-2020-12") {
+		throw new Error("[Seal] toJsonSchema() is not supported on ComputedValidator / ManagedValidator. Computed fields are runtime-only and have no input JSON Schema representation. ObjectValidator.toJsonSchema() automatically skips computed fields — do not call toJsonSchema() on a computed validator directly.");
+	}
+};
+
+//#endregion
+//#region ../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 require_required_methods.BaseValidator {
+	constructor(schema, errorMessage) {
+		super();
+		this.schema = schema;
+		this.shouldAllowUnknown = false;
+		this.allowedKeys = [];
+		this.hasUnknownKeyRule = false;
+		this.addMutableRule(require_required_methods.objectRule, errorMessage);
+	}
+	/**
+	* Check if value is an object type (plain object, not array or date)
+	*/
+	matchesType(value) {
+		return (0, _mongez_supportive_is.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 (!(0, _mongez_supportive_is.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(require_required_methods.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 (data === void 0) return result;
+		const errors = [];
+		const validatedData = {};
+		const validationPromises = Object.entries(this.schema).filter(([, validator]) => !this.isComputedValidator(validator)).map(async ([key, validator]) => {
+			const value = mutatedData?.[key] !== void 0 ? mutatedData[key] : validator.getDefaultValue();
+			const childContext = {
+				...context,
+				parent: mutatedData,
+				value,
+				key,
+				path: require_required_methods.setKeyPath(context.path, key)
+			};
+			const childResult = await validator.validate(value, childContext);
+			if (childResult.data !== void 0 && !validator.isOmitted()) validatedData[key] = childResult.data;
+			if (childResult.isValid === false) errors.push(...childResult.errors);
+		});
+		await Promise.all(validationPromises);
+		if (errors.length > 0) return {
+			isValid: false,
+			errors,
+			data: void 0
+		};
+		const computedFields = this.getComputedFields();
+		const computedPromises = Object.entries(computedFields).map(async ([key, validator]) => {
+			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) errors.push(...childResult.errors);
+		});
+		await Promise.all(computedPromises);
+		if (errors.length > 0) return {
+			isValid: false,
+			errors,
+			data: void 0
+		};
+		const cleanedData = removeUndefinedValues(validatedData);
+		const transformedData = await this.startTransformationPipeline(cleanedData, context);
+		return {
+			isValid: true,
+			errors: [],
+			data: this.shouldAllowUnknown === false ? transformedData : {
+				...transformedData,
+				...(0, _mongez_reinforcements.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 = require_required_methods.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) require_required_methods.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 (!(0, _mongez_supportive_is.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
+//#region ../seal/src/object.ts
+/** Create an object schema without importing the complete `v` factory. */
+const object = (schema, errorMessage) => new ObjectValidator(schema, errorMessage);
+
+//#endregion
+Object.defineProperty(exports, 'ComputedValidator', {
+  enumerable: true,
+  get: function () {
+    return ComputedValidator;
+  }
+});
+Object.defineProperty(exports, 'ObjectValidator', {
+  enumerable: true,
+  get: function () {
+    return ObjectValidator;
+  }
+});
+Object.defineProperty(exports, 'jsonMutator', {
+  enumerable: true,
+  get: function () {
+    return jsonMutator;
+  }
+});
+Object.defineProperty(exports, 'object', {
+  enumerable: true,
+  get: function () {
+    return object;
+  }
+});
+Object.defineProperty(exports, 'objectTrimMutator', {
+  enumerable: true,
+  get: function () {
+    return objectTrimMutator;
+  }
+});
+Object.defineProperty(exports, 'stripUnknownMutator', {
+  enumerable: true,
+  get: function () {
+    return stripUnknownMutator;
+  }
+});
+//# sourceMappingURL=object-_2YHdBxJ.cjs.map