@hg-ts/validation 0.5.17 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/validation",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -16,10 +16,10 @@
     "lint:ts:fix": "lint-ts --fix"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.17",
-    "@hg-ts/exception": "0.5.17",
-    "@hg-ts/linter": "0.5.17",
-    "@hg-ts/types": "0.5.17",
+    "@hg-ts-config/typescript": "0.5.18",
+    "@hg-ts/exception": "0.5.18",
+    "@hg-ts/linter": "0.5.18",
+    "@hg-ts/types": "0.5.18",
     "@types/node": "22.19.1",
     "eslint": "9.18.0",
     "reflect-metadata": "0.2.2",
@@ -28,7 +28,7 @@
     "typescript": "5.7.3"
   },
   "peerDependencies": {
-    "@hg-ts/exception": "0.5.17",
+    "@hg-ts/exception": "0.5.18",
     "reflect-metadata": "*",
     "tslib": "*"
   },

package/src/dto.ts

@@ -0,0 +1,35 @@
+import {
+	infer as ZodInfer,
+	ZodSchema,
+	ZodType,
+} from 'zod';
+
+export type ZodDto<TOutput = any, TInput = TOutput> = {
+	new (): TOutput;
+	isZodDto: true;
+	schema: ZodSchema<TOutput, TInput>;
+	create(input: unknown): TOutput;
+}
+
+export function createZodDto<T extends ZodType>(
+	schema: T,
+): ZodDto<ZodInfer<T>> {
+	abstract class AugmentedZodDto {
+		public static isZodDto = true;
+		public static schema = schema;
+
+		public static create(input: unknown): AugmentedZodDto {
+			return this.schema.parse(input) as AugmentedZodDto;
+		}
+	}
+
+	return AugmentedZodDto as unknown as ZodDto<ZodInfer<T>>;
+}
+
+export function isZodDto(value: unknown): value is ZodDto {
+	if (!value || typeof value !== 'function') {
+		return false;
+	}
+
+	return 'isZodDto' in value && value.isZodDto === true;
+}

package/src/extensions.ts

@@ -0,0 +1,87 @@
+import zod, {
+	core,
+	infer as ZodInfer,
+	ZodBoolean,
+	ZodPipe,
+	ZodTransform,
+	ZodType,
+} from 'zod';
+import 'zod-openapi';
+
+import {
+	createZodDto,
+	ZodDto,
+} from './dto.js';
+import { ValidationException } from './validation.exception.js';
+
+declare module 'zod' {
+	// eslint-disable-next-line @typescript/consistent-type-definitions
+	interface ZodType<Output = unknown, Input = unknown> {
+		enforceEnv<T extends ZodType<Output, Input>>(
+			this: T,
+			name: string
+		): ZodPipe<T, ZodTransform<Awaited<ZodInfer<T> | string>>>;
+		transformBooleanString<T extends ZodType<Output, Input>>(
+			this: T,
+		): ZodPipe<ZodPipe<T, ZodTransform<boolean, core.output<T>>>, ZodBoolean>;
+		toClass<T extends ZodType<Output, Input>>(this: T): ZodDto<ZodInfer<T>>;
+		describe(description: string): this;
+		example(example: Input): this;
+	}
+}
+
+zod.ZodType.prototype.enforceEnv = function<T extends ZodType>(
+	this: T,
+	name: string,
+): ZodPipe<T, ZodTransform<Awaited<ZodInfer<T> | string>>> {
+	return this.transform(value => process.env[name] ?? value);
+};
+
+zod.ZodType.prototype.parse = function<
+	T extends ZodType<Output, Input>,
+	Input = unknown,
+	Output = unknown,
+>(
+	this: T,
+	value: unknown,
+): Output {
+	const { success, error, data } = this.safeParse(value);
+
+	if (success) {
+		return data;
+	}
+
+	throw new ValidationException(error);
+};
+
+zod.ZodType.prototype.parseAsync = async function<
+	T extends ZodType<Output, Input>,
+	Input = unknown,
+	Output = unknown,
+>(
+	this: T,
+	value: unknown,
+): Promise<Output> {
+	const { success, error, data } = await this.safeParseAsync(value);
+
+	if (success) {
+		return data;
+	}
+
+	throw new ValidationException(error);
+};
+
+
+zod.ZodType.prototype.transformBooleanString = function<T extends ZodType>(
+	this: T,
+): ZodPipe<ZodPipe<T, ZodTransform<boolean, core.output<T>>>, ZodBoolean> {
+	return this
+		.transform(value => (typeof value === 'boolean' ? value : value === 'true'))
+		.pipe(zod.boolean());
+};
+
+zod.ZodType.prototype.toClass = function<T extends ZodType>(
+	this: T,
+): ZodDto<ZodInfer<T>> {
+	return createZodDto(this);
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+import './extensions.js';
+import zod from 'zod';
+
+export * from 'zod';
+export { isZodDto, ZodDto } from './dto.js';
+export * from './validation.exception.js';
+export * from './schemas.js';
+
+export { createSchema } from 'zod-openapi';
+
+export default zod;

package/src/schemas.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const baseExceptionSchema = z.object({
+	name: z.string(),
+	code: z.number().nullable(),
+	message: z.string(),
+	stack: z.array(z.string()),
+});
+
+export const bufferSchema = z
+	.instanceof(Buffer)
+	.meta({
+		type: 'string',
+		format: 'binary',
+	});

package/src/validation.exception.ts

@@ -0,0 +1,30 @@
+import {
+	BaseException,
+	JSONBaseException,
+} from '@hg-ts/exception';
+
+import {
+	ZodError,
+	ZodIssue,
+} from 'zod';
+
+export type JSONValidationException = JSONBaseException & {
+	issues: ZodIssue[];
+};
+
+export class ValidationException extends BaseException {
+	private readonly issues: ZodIssue[];
+
+	public constructor(originalError: ZodError) {
+		super('Validation failed');
+
+		this.issues = originalError.issues;
+	}
+
+	public override toJSON(): JSONValidationException {
+		return {
+			...super.toJSON(),
+			issues: this.issues.map(item => ({ ...item })),
+		};
+	}
+}