moonflower 1.2.0 → 1.3.1

package/dist/validators/validateMissingParams.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateMissingParams.mjs","sources":["../../src/validators/validateMissingParams.ts"],"sourcesContent":["import z from 'zod'\n\nimport { ValidationError } from '../errors/UserFacingErrors'\nimport { getMissingParamMessage } from '../utils/validationMessages'\nimport { MaybeOptionalValidatorUnion, Validator } from './types'\n\nexport function validateMissingParams<ValidatorsT extends Record<string, MaybeOptionalValidatorUnion>>(\n\tparams: { name: string; validator: Pick<Validator<unknown>, 'description' | 'errorMessage'> }[],\n\tprovidedParams: Record<string, unknown>,\n\tvalidators: ValidatorsT,\n\tsuffix: 'body' | 'query' | 'path',\n) {\n\tconst missingParams = params.filter((param) => {\n\t\tlet isOptional = validators[param.name].optional\n\t\tif (validators[param.name] instanceof z.ZodType) {\n\t\t\tisOptional = (validators[param.name] as z.ZodType).safeParse(undefined).success\n\t\t}\n\n\t\treturn providedParams[param.name] === undefined && !isOptional\n\t})\n\n\tif (missingParams.length > 0) {\n\t\tthrow new ValidationError(\n\t\t\t`Missing ${suffix} params: ${missingParams.map((param) => getMissingParamMessage(param)).join(', ')}`,\n\t\t)\n\t}\n}\n"],"names":["validateMissingParams","params","providedParams","validators","suffix","missingParams","param","isOptional","z","ValidationError","getMissingParamMessage"],"mappings":";;;AAMO,SAASA,EACfC,GACAC,GACAC,GACAC,GACC;AACD,QAAMC,IAAgBJ,EAAO,OAAO,CAACK,MAAU;AAC9C,QAAIC,IAAaJ,EAAWG,EAAM,IAAI,EAAE;AACxC,WAAIH,EAAWG,EAAM,IAAI,aAAaE,EAAE,YACvCD,IAAcJ,EAAWG,EAAM,IAAI,EAAgB,UAAU,MAAS,EAAE,UAGlEJ,EAAeI,EAAM,IAAI,MAAM,UAAa,CAACC;AAAA,EAAA,CACpD;AAEG,MAAAF,EAAc,SAAS;AAC1B,UAAM,IAAII;AAAA,MACT,WAAWL,CAAM,YAAYC,EAAc,IAAI,CAACC,MAAUI,EAAuBJ,CAAK,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IACpG;AAEF;"}

package/dist/validators/validateParam.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../node_modules/zod/v4/classic/external.cjs"),a=require("../utils/getValueAsNullableString.cjs"),c=require("../node_modules/zod/v4/classic/errors.cjs");function o(e,r){try{const t=s(e,r),n=l(e,r),u=f(e,n);return{validated:t&&u,parsedValue:n,exception:null}}catch(t){return{validated:!1,parsedValue:null,exception:p(t)}}}function s(e,r){return"prevalidate"in e&&typeof e.prevalidate=="function"?e.prevalidate(a.getValueAsNullableString(r)):!0}function l(e,r){if(e instanceof i.ZodType){const t=(()=>{try{return typeof r=="string"?JSON.parse(r):r}catch{return r}})();return e.parse(t)}return e.parse(a.getValueAsNullableString(r))}function f(e,r){return"validate"in e&&typeof e.validate=="function"?e.validate(r):!0}function p(e){return e instanceof c.ZodError?i.treeifyError(e).errors.join("; ").replace("Invalid input: ",""):"Validation failed"}exports.validateParam=o;
+//# sourceMappingURL=validateParam.cjs.map

package/dist/validators/validateParam.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateParam.cjs","sources":["../../src/validators/validateParam.ts"],"sourcesContent":["import z, { ZodError } from 'zod'\n\nimport { getValueAsNullableString } from '../utils/getValueAsNullableString'\nimport { ValidatorUnion } from './types'\n\nexport function validateParam(\n\tvalidator: ValidatorUnion,\n\tvalue: string | number | boolean | object | null,\n): {\n\tvalidated: boolean\n\tparsedValue: unknown\n\texception: string | null\n} {\n\ttry {\n\t\tconst prevalidatorSuccess = runPrevalidator(validator, value)\n\t\tconst parsedValue = runParser(validator, value)\n\t\tconst validatorSuccess = runValidator(validator, parsedValue)\n\n\t\treturn {\n\t\t\tvalidated: prevalidatorSuccess && validatorSuccess,\n\t\t\tparsedValue,\n\t\t\texception: null,\n\t\t}\n\t} catch (error) {\n\t\tconst exception = getErrorMessage(error)\n\t\treturn { validated: false, parsedValue: null, exception }\n\t}\n}\n\nfunction runPrevalidator(validator: ValidatorUnion, value: string | number | boolean | object | null) {\n\t// Legacy validator\n\tif ('prevalidate' in validator && typeof validator.prevalidate === 'function') {\n\t\treturn validator.prevalidate(getValueAsNullableString(value))\n\t}\n\t// Zod (skip)\n\treturn true\n}\n\nfunction runParser(validator: ValidatorUnion, value: string | number | boolean | object | null) {\n\t// Zod validator\n\tif (validator instanceof z.ZodType) {\n\t\tconst coercedValue = (() => {\n\t\t\ttry {\n\t\t\t\treturn typeof value === 'string' ? JSON.parse(value) : value\n\t\t\t} catch {\n\t\t\t\treturn value\n\t\t\t}\n\t\t})()\n\t\treturn validator.parse(coercedValue)\n\t}\n\t// Legacy validator\n\treturn validator.parse(getValueAsNullableString(value))\n}\n\nfunction runValidator(validator: ValidatorUnion, parsedValue: unknown) {\n\t// Legacy validator\n\tif ('validate' in validator && typeof validator.validate === 'function') {\n\t\treturn validator.validate(parsedValue)\n\t}\n\t// Zod (skip)\n\treturn true\n}\n\nfunction getErrorMessage(error: unknown) {\n\tif (error instanceof ZodError) {\n\t\treturn z.treeifyError(error).errors.join('; ').replace('Invalid input: ', '')\n\t}\n\treturn 'Validation failed'\n}\n"],"names":["validateParam","validator","value","prevalidatorSuccess","runPrevalidator","parsedValue","runParser","validatorSuccess","runValidator","error","getErrorMessage","getValueAsNullableString","z","coercedValue","ZodError"],"mappings":"yPAKgB,SAAAA,EACfC,EACAC,EAKC,CACG,GAAA,CACG,MAAAC,EAAsBC,EAAgBH,EAAWC,CAAK,EACtDG,EAAcC,EAAUL,EAAWC,CAAK,EACxCK,EAAmBC,EAAaP,EAAWI,CAAW,EAErD,MAAA,CACN,UAAWF,GAAuBI,EAClC,YAAAF,EACA,UAAW,IACZ,QACQI,EAAO,CAEf,MAAO,CAAE,UAAW,GAAO,YAAa,KAAM,UAD5BC,EAAgBD,CAAK,CACiB,CAAA,CAE1D,CAEA,SAASL,EAAgBH,EAA2BC,EAAkD,CAErG,MAAI,gBAAiBD,GAAa,OAAOA,EAAU,aAAgB,WAC3DA,EAAU,YAAYU,EAAyB,yBAAAT,CAAK,CAAC,EAGtD,EACR,CAEA,SAASI,EAAUL,EAA2BC,EAAkD,CAE3F,GAAAD,aAAqBW,EAAE,QAAS,CACnC,MAAMC,GAAgB,IAAM,CACvB,GAAA,CACH,OAAO,OAAOX,GAAU,SAAW,KAAK,MAAMA,CAAK,EAAIA,CAAA,MAChD,CACA,OAAAA,CAAA,CACR,GACE,EACI,OAAAD,EAAU,MAAMY,CAAY,CAAA,CAGpC,OAAOZ,EAAU,MAAMU,EAAyB,yBAAAT,CAAK,CAAC,CACvD,CAEA,SAASM,EAAaP,EAA2BI,EAAsB,CAEtE,MAAI,aAAcJ,GAAa,OAAOA,EAAU,UAAa,WACrDA,EAAU,SAASI,CAAW,EAG/B,EACR,CAEA,SAASK,EAAgBD,EAAgB,CACxC,OAAIA,aAAiBK,EAAAA,SACbF,EAAE,aAAaH,CAAK,EAAE,OAAO,KAAK,IAAI,EAAE,QAAQ,kBAAmB,EAAE,EAEtE,mBACR"}

package/dist/validators/validateParam.d.ts

@@ -0,0 +1,8 @@
+import { ValidatorUnion } from './types';
+
+export declare function validateParam(validator: ValidatorUnion, value: string | number | boolean | object | null): {
+    validated: boolean;
+    parsedValue: unknown;
+    exception: string | null;
+};
+//# sourceMappingURL=validateParam.d.ts.map

package/dist/validators/validateParam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateParam.d.ts","sourceRoot":"","sources":["../../src/validators/validateParam.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAExC,wBAAgB,aAAa,CAC5B,SAAS,EAAE,cAAc,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAC9C;IACF,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB,CAeA"}

package/dist/validators/validateParam.mjs

@@ -0,0 +1,41 @@
+import * as i from "../node_modules/zod/v4/classic/external.mjs";
+import { getValueAsNullableString as o } from "../utils/getValueAsNullableString.mjs";
+import { ZodError as u } from "../node_modules/zod/v4/classic/errors.mjs";
+function m(r, e) {
+  try {
+    const t = c(r, e), n = s(r, e), a = f(r, n);
+    return {
+      validated: t && a,
+      parsedValue: n,
+      exception: null
+    };
+  } catch (t) {
+    return { validated: !1, parsedValue: null, exception: p(t) };
+  }
+}
+function c(r, e) {
+  return "prevalidate" in r && typeof r.prevalidate == "function" ? r.prevalidate(o(e)) : !0;
+}
+function s(r, e) {
+  if (r instanceof i.ZodType) {
+    const t = (() => {
+      try {
+        return typeof e == "string" ? JSON.parse(e) : e;
+      } catch {
+        return e;
+      }
+    })();
+    return r.parse(t);
+  }
+  return r.parse(o(e));
+}
+function f(r, e) {
+  return "validate" in r && typeof r.validate == "function" ? r.validate(e) : !0;
+}
+function p(r) {
+  return r instanceof u ? i.treeifyError(r).errors.join("; ").replace("Invalid input: ", "") : "Validation failed";
+}
+export {
+  m as validateParam
+};
+//# sourceMappingURL=validateParam.mjs.map

package/dist/validators/validateParam.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateParam.mjs","sources":["../../src/validators/validateParam.ts"],"sourcesContent":["import z, { ZodError } from 'zod'\n\nimport { getValueAsNullableString } from '../utils/getValueAsNullableString'\nimport { ValidatorUnion } from './types'\n\nexport function validateParam(\n\tvalidator: ValidatorUnion,\n\tvalue: string | number | boolean | object | null,\n): {\n\tvalidated: boolean\n\tparsedValue: unknown\n\texception: string | null\n} {\n\ttry {\n\t\tconst prevalidatorSuccess = runPrevalidator(validator, value)\n\t\tconst parsedValue = runParser(validator, value)\n\t\tconst validatorSuccess = runValidator(validator, parsedValue)\n\n\t\treturn {\n\t\t\tvalidated: prevalidatorSuccess && validatorSuccess,\n\t\t\tparsedValue,\n\t\t\texception: null,\n\t\t}\n\t} catch (error) {\n\t\tconst exception = getErrorMessage(error)\n\t\treturn { validated: false, parsedValue: null, exception }\n\t}\n}\n\nfunction runPrevalidator(validator: ValidatorUnion, value: string | number | boolean | object | null) {\n\t// Legacy validator\n\tif ('prevalidate' in validator && typeof validator.prevalidate === 'function') {\n\t\treturn validator.prevalidate(getValueAsNullableString(value))\n\t}\n\t// Zod (skip)\n\treturn true\n}\n\nfunction runParser(validator: ValidatorUnion, value: string | number | boolean | object | null) {\n\t// Zod validator\n\tif (validator instanceof z.ZodType) {\n\t\tconst coercedValue = (() => {\n\t\t\ttry {\n\t\t\t\treturn typeof value === 'string' ? JSON.parse(value) : value\n\t\t\t} catch {\n\t\t\t\treturn value\n\t\t\t}\n\t\t})()\n\t\treturn validator.parse(coercedValue)\n\t}\n\t// Legacy validator\n\treturn validator.parse(getValueAsNullableString(value))\n}\n\nfunction runValidator(validator: ValidatorUnion, parsedValue: unknown) {\n\t// Legacy validator\n\tif ('validate' in validator && typeof validator.validate === 'function') {\n\t\treturn validator.validate(parsedValue)\n\t}\n\t// Zod (skip)\n\treturn true\n}\n\nfunction getErrorMessage(error: unknown) {\n\tif (error instanceof ZodError) {\n\t\treturn z.treeifyError(error).errors.join('; ').replace('Invalid input: ', '')\n\t}\n\treturn 'Validation failed'\n}\n"],"names":["validateParam","validator","value","prevalidatorSuccess","runPrevalidator","parsedValue","runParser","validatorSuccess","runValidator","error","getErrorMessage","getValueAsNullableString","z","coercedValue","ZodError"],"mappings":";;;AAKgB,SAAAA,EACfC,GACAC,GAKC;AACG,MAAA;AACG,UAAAC,IAAsBC,EAAgBH,GAAWC,CAAK,GACtDG,IAAcC,EAAUL,GAAWC,CAAK,GACxCK,IAAmBC,EAAaP,GAAWI,CAAW;AAErD,WAAA;AAAA,MACN,WAAWF,KAAuBI;AAAA,MAClC,aAAAF;AAAA,MACA,WAAW;AAAA,IACZ;AAAA,WACQI,GAAO;AAEf,WAAO,EAAE,WAAW,IAAO,aAAa,MAAM,WAD5BC,EAAgBD,CAAK,EACiB;AAAA,EAAA;AAE1D;AAEA,SAASL,EAAgBH,GAA2BC,GAAkD;AAErG,SAAI,iBAAiBD,KAAa,OAAOA,EAAU,eAAgB,aAC3DA,EAAU,YAAYU,EAAyBT,CAAK,CAAC,IAGtD;AACR;AAEA,SAASI,EAAUL,GAA2BC,GAAkD;AAE3F,MAAAD,aAAqBW,EAAE,SAAS;AACnC,UAAMC,KAAgB,MAAM;AACvB,UAAA;AACH,eAAO,OAAOX,KAAU,WAAW,KAAK,MAAMA,CAAK,IAAIA;AAAA,MAAA,QAChD;AACA,eAAAA;AAAA,MAAA;AAAA,IACR,GACE;AACI,WAAAD,EAAU,MAAMY,CAAY;AAAA,EAAA;AAGpC,SAAOZ,EAAU,MAAMU,EAAyBT,CAAK,CAAC;AACvD;AAEA,SAASM,EAAaP,GAA2BI,GAAsB;AAEtE,SAAI,cAAcJ,KAAa,OAAOA,EAAU,YAAa,aACrDA,EAAU,SAASI,CAAW,IAG/B;AACR;AAEA,SAASK,EAAgBD,GAAgB;AACxC,SAAIA,aAAiBK,IACbF,EAAE,aAAaH,CAAK,EAAE,OAAO,KAAK,IAAI,EAAE,QAAQ,mBAAmB,EAAE,IAEtE;AACR;"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "moonflower",
-	"version": "1.2.0",
+	"version": "1.3.1",
 	"description": "",
 	"author": "tenebrie",
 	"license": "MIT",
@@ -124,12 +124,19 @@
 	},
 	"dependencies": {
 		"ts-morph": "^24.0.0",
-		"typescript": "^5.7.2"
+		"typescript": "^5.7.2",
+		"yargs": "^17.7.2"
 	},
 	"peerDependencies": {
 		"@koa/router": "^13.1.0",
 		"koa": "^2.15.3",
-		"koa-bodyparser": "^4.4.1"
+		"koa-bodyparser": "^4.4.1",
+		"zod": "4.3.6"
+	},
+	"peerDependenciesMeta": {
+		"zod": {
+			"optional": true
+		}
 	},
 	"devDependencies": {
 		"@koa/router": "^13.1.0",
@@ -148,6 +155,7 @@
 		"eslint-plugin-simple-import-sort": "^12.1.1",
 		"eslint-plugin-unused-imports": "^4.1.4",
 		"jest": "29.7.0",
+		"zod": "4.3.6",
 		"koa": "^2.15.3",
 		"koa-bodyparser": "^4.4.1",
 		"node-mocks-http": "^1.16.2",
@@ -159,7 +167,6 @@
 		"tsconfig-paths": "4.2.0",
 		"vite": "^6.2.2",
 		"vite-plugin-dts": "^3.7.3",
-		"vitest": "^3.0.9",
-		"yargs": "^17.7.2"
+		"vitest": "^3.0.9"
 	}
 }

package/{cli → src/cli}/cli.ts

@@ -3,9 +3,9 @@ import * as path from 'path'
 import yargs, { ArgumentsCamelCase } from 'yargs'
 import { hideBin } from 'yargs/helpers'
 
-import { prepareOpenApiSpec } from '../src/openapi/analyzerModule/analyzerModule'
-import { generateOpenApiSpec } from '../src/openapi/generatorModule'
-import { OpenApiManager } from '../src/openapi/manager/OpenApiManager'
+import { prepareOpenApiSpec } from '../openapi/analyzerModule/analyzerModule'
+import { generateOpenApiSpec } from '../openapi/generatorModule'
+import { OpenApiManager } from '../openapi/manager/OpenApiManager'
 import { printAnalysisStats } from './prettyprint'
 
 const originalConsole = console.info
@@ -31,12 +31,22 @@ yargs(hideBin(process.argv))
 				type: 'string',
 				coerce: (f) => path.resolve(f),
 			},
+
+			force: {
+				describe: 'Overwrite existing file',
+				type: 'boolean',
+				default: false,
+			},
 		},
 
-		handler(argv: ArgumentsCamelCase<{ targetPath: string; tsConfigPath?: string }>) {
+		handler(argv: ArgumentsCamelCase<{ targetPath: string; tsConfigPath?: string; force: boolean }>) {
 			if (fs.existsSync(argv.targetPath)) {
-				console.error(`[Error] File already exists at ${argv.targetPath}`)
-				return
+				if (!argv.force && !isValidMoonflowerOutput(argv.targetPath)) {
+					console.error(
+						`[Error] File already exists at ${argv.targetPath} and does not appear to be a moonflower output. Use --force to overwrite.`,
+					)
+					return
+				}
 			}
 
 			if (argv.tsConfigPath && !fs.existsSync(argv.tsConfigPath)) {
@@ -57,3 +67,13 @@ yargs(hideBin(process.argv))
 	})
 	.demandCommand()
 	.parse()
+
+function isValidMoonflowerOutput(filePath: string): boolean {
+	try {
+		const content = fs.readFileSync(filePath, 'utf-8')
+		const parsed = JSON.parse(content)
+		return typeof parsed === 'object' && parsed !== null && typeof parsed.openapi === 'string'
+	} catch {
+		return false
+	}
+}

package/{cli → src/cli}/prettyprint.ts

@@ -1,5 +1,5 @@
-import { ApiAnalysisStats } from '../src/openapi/manager/OpenApiManager'
-import { Logger } from '../src/utils/logger'
+import { ApiAnalysisStats } from '../openapi/manager/OpenApiManager'
+import { Logger } from '../utils/logger'
 
 export const printAnalysisStats = (stats: ApiAnalysisStats) => {
 	stats.explicitRouterFiles.forEach((file) => printRouterFile(file))

package/src/errors/UserFacingErrors.ts

@@ -34,12 +34,66 @@ export class InternalServerError extends BaseHttpError {
 	}
 }
 
+export class ForbiddenError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.FORBIDDEN, message)
+	}
+}
+
+export class MethodNotAllowedError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.METHOD_NOT_ALLOWED, message)
+	}
+}
+
+export class ConflictError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.CONFLICT, message)
+	}
+}
+
+export class GoneError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.GONE, message)
+	}
+}
+
+export class UnprocessableEntityError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.UNPROCESSABLE_ENTITY, message)
+	}
+}
+
+export class TooManyRequestsError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.TOO_MANY_REQUESTS, message)
+	}
+}
+
+export class NotImplementedError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.NOT_IMPLEMENTED, message)
+	}
+}
+
+export class BadGatewayError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.BAD_GATEWAY, message)
+	}
+}
+
 export class ServiceUnavailableError extends BaseHttpError {
 	constructor(message: string) {
 		super(StatusCodes.SERVICE_UNAVAILABLE, message)
 	}
 }
 
+export class GatewayTimeoutError extends BaseHttpError {
+	constructor(message: string) {
+		super(StatusCodes.GATEWAY_TIMEOUT, message)
+	}
+}
+
 // To be used later
 // export const errorNameToStatusCode = (name: string): number => {
 // 	switch (name) {

package/src/hooks/usePathParams.spec.ts

@@ -1,3 +1,6 @@
+import { expectTypeOf } from 'vitest'
+import z from 'zod'
+
 import {
 	BooleanValidator,
 	NumberValidator,
@@ -158,4 +161,28 @@ describe('usePathParams', () => {
 		expect(test).toThrow(ValidationError)
 		expect(test).toThrow("Failed route param validation: 'testParam' (Description)")
 	})
+
+	describe('zod validators', () => {
+		it('parses required params when present', () => {
+			const ctx = mockContextPath(mockContext(), '/test/:stringParam/:numberParam/:booleanParam', {
+				stringParam: 'test_string',
+				numberParam: '12',
+				booleanParam: 'true',
+			})
+
+			const params = usePathParams(ctx, {
+				stringParam: z.string(),
+				numberParam: z.number(),
+				booleanParam: z.boolean(),
+			})
+
+			expect(params.stringParam).toEqual('test_string')
+			expect(params.numberParam).toEqual(12)
+			expect(params.booleanParam).toEqual(true)
+
+			expectTypeOf(params.stringParam).toEqualTypeOf<string>()
+			expectTypeOf(params.numberParam).toEqualTypeOf<number>()
+			expectTypeOf(params.booleanParam).toEqualTypeOf<boolean>()
+		})
+	})
 })

package/src/hooks/usePathParams.ts

@@ -5,6 +5,7 @@ import { keysOf } from '../utils/object'
 import { CleanUpPathParam } from '../utils/TypeUtils'
 import { getValidationResultMessage } from '../utils/validationMessages'
 import { Validator } from '../validators/types'
+import { validateParam } from '../validators/validateParam'
 
 type CheckIfOptional<T, B> = B extends string ? (B extends `${string}?` ? T | undefined : T) : never
 
@@ -50,21 +51,12 @@ export const usePathParams = <
 
 		// Param is optional and is not provided - skip validation
 		if (paramValue === undefined) {
-			return { param, validated: true }
+			return { param, validated: true, parsedValue: undefined, exception: null }
 		}
 
-		try {
-			const validatorObject = param.validator
-			const prevalidatorSuccess = !validatorObject.prevalidate || validatorObject.prevalidate(paramValue)
-			const parsedValue = validatorObject.parse(paramValue)
-			const validatorSuccess = !validatorObject.validate || validatorObject.validate(parsedValue)
-			return {
-				param,
-				validated: prevalidatorSuccess && validatorSuccess,
-				parsedValue,
-			}
-		} catch {
-			return { param, validated: false }
+		return {
+			...validateParam(param.validator, paramValue),
+			param,
 		}
 	})
 

package/src/hooks/useQueryParams.spec.ts

@@ -1,3 +1,6 @@
+import { expectTypeOf } from 'vitest'
+import z from 'zod'
+
 import {
 	BigIntValidator,
 	BooleanValidator,
@@ -221,4 +224,100 @@ describe('useQueryParams', () => {
 		expect(test).toThrow(ValidationError)
 		expect(test).toThrow("Failed query param validation: 'testParam' (Description)")
 	})
+
+	describe('zod validators', () => {
+		it('parses required params when present', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				stringParam: 'test_string',
+				numberParam: '12',
+				booleanParam: 'true',
+				objectParam: JSON.stringify({
+					foo: 'aaa',
+					bar: 'bbb',
+				}),
+				arrayParam: JSON.stringify([
+					{
+						foo: 'aaa',
+						bar: 'bbb',
+					},
+					{
+						foo: 'ccc',
+						bar: 'ddd',
+					},
+				]),
+			})
+
+			const params = useQueryParams(ctx, {
+				stringParam: z.string(),
+				numberParam: z.number(),
+				booleanParam: z.boolean(),
+				objectParam: z.object({
+					foo: z.string(),
+					bar: z.string(),
+				}),
+				arrayParam: z.array(
+					z.object({
+						foo: z.string(),
+						bar: z.string(),
+					}),
+				),
+			})
+
+			expect(params.stringParam).toEqual('test_string')
+			expect(params.numberParam).toEqual(12)
+			expect(params.booleanParam).toEqual(true)
+			expect(params.objectParam).toEqual({ foo: 'aaa', bar: 'bbb' })
+			expect(params.arrayParam).toEqual([
+				{ foo: 'aaa', bar: 'bbb' },
+				{ foo: 'ccc', bar: 'ddd' },
+			])
+
+			expectTypeOf(params.stringParam).toEqualTypeOf<string>()
+			expectTypeOf(params.numberParam).toEqualTypeOf<number>()
+			expectTypeOf(params.booleanParam).toEqualTypeOf<boolean>()
+			expectTypeOf(params.objectParam).toEqualTypeOf<{ foo: string; bar: string }>()
+			expectTypeOf(params.arrayParam).toEqualTypeOf<{ foo: string; bar: string }[]>()
+		})
+
+		it('throws if a required param is missing', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				stringParam: 'test_string',
+			})
+
+			const test = () => {
+				useQueryParams(ctx, {
+					stringParam: z.string(),
+					numberParam: z.number(),
+				})
+			}
+
+			expect(test).toThrow(ValidationError)
+			expect(test).toThrow("Missing query params: 'numberParam'")
+		})
+
+		it('allows missing params when optional', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				stringParam: 'test_string',
+			})
+
+			const test = () => {
+				useQueryParams(ctx, {
+					stringParam: z.string(),
+					numberParam: z.number().optional(),
+				})
+			}
+
+			expect(test).not.toThrow(ValidationError)
+		})
+
+		it('infers the return type of optional params', () => {
+			const ctx = mockContextQuery(mockContext(), {})
+
+			const params = useQueryParams(ctx, {
+				numberParam: z.number().optional(),
+			})
+
+			expectTypeOf(params.numberParam).toEqualTypeOf<number | undefined>()
+		})
+	})
 })

package/src/hooks/useQueryParams.ts

@@ -1,17 +1,23 @@
 import { ParameterizedContext } from 'koa'
+import z from 'zod'
 
 import { ValidationError } from '../errors/UserFacingErrors'
 import { keysOf } from '../utils/object'
-import { getMissingParamMessage, getValidationResultMessage } from '../utils/validationMessages'
+import { getValidationResultMessage } from '../utils/validationMessages'
 import { Validator } from '../validators/types'
+import { validateMissingParams } from '../validators/validateMissingParams'
+import { validateParam } from '../validators/validateParam'
 
 type CheckIfOptional<T, B extends boolean | undefined> = B extends false ? T : T | undefined
 
-type ValidatedData<T extends Record<string, Validator<any>>> = {
-	[K in keyof T]: CheckIfOptional<ReturnType<T[K]['parse']>, T[K]['optional']>
+type ValidatedData<T extends Record<string, Validator<any> | z.ZodType<any>>> = {
+	[K in keyof T]: CheckIfOptional<
+		ReturnType<T[K] extends Validator<any> ? T[K]['parse'] : T[K]['parse']>,
+		T[K] extends Validator<any> ? T[K]['optional'] : false
+	>
 }
 
-export const useQueryParams = <ValidatorsT extends Record<string, Validator<any>>>(
+export const useQueryParams = <ValidatorsT extends Record<string, Validator<any> | z.ZodType<any>>>(
 	ctx: ParameterizedContext,
 	validators: ValidatorsT,
 ): ValidatedData<ValidatorsT> => {
@@ -21,34 +27,19 @@ export const useQueryParams = <ValidatorsT extends Record<string, Validator<any>
 		validator: validators[name],
 	}))
 
-	const missingParams = params.filter((param) => !query[param.name] && !param.validator.optional)
-
-	if (missingParams.length > 0) {
-		throw new ValidationError(
-			`Missing query params: ${missingParams.map((param) => getMissingParamMessage(param)).join(', ')}`,
-		)
-	}
+	validateMissingParams(params, query, validators, 'query')
 
 	const validationResults = params.map((param) => {
-		const paramValue = query[param.name] as string
+		const paramValue = query[param.name]
 
 		// Param is optional and is not provided - skip validation
 		if (paramValue === undefined) {
-			return { param, validated: true }
+			return { param, validated: true, parsedValue: undefined, exception: null }
 		}
 
-		try {
-			const validatorObject = param.validator
-			const prevalidatorSuccess = !validatorObject.prevalidate || validatorObject.prevalidate(paramValue)
-			const parsedValue = validatorObject.parse(paramValue)
-			const validatorSuccess = !validatorObject.validate || validatorObject.validate(parsedValue)
-			return {
-				param,
-				validated: prevalidatorSuccess && validatorSuccess,
-				parsedValue,
-			}
-		} catch {
-			return { param, validated: false }
+		return {
+			...validateParam(param.validator, paramValue),
+			param,
 		}
 	})
 

package/src/hooks/useRequestBody.spec.ts

@@ -1,3 +1,6 @@
+import { expectTypeOf } from 'vitest'
+import z from 'zod'
+
 import {
 	BooleanValidator,
 	NullableNumberValidator,
@@ -241,4 +244,100 @@ describe('useRequestBody', () => {
 		expect(test).toThrow(ValidationError)
 		expect(test).toThrow("Failed body param validation: 'testParam' (Description)")
 	})
+
+	describe('zod validators', () => {
+		it('parses required params when present', () => {
+			const ctx = mockContextBody(mockContext(), {
+				stringParam: 'test_string',
+				numberParam: '12',
+				booleanParam: 'true',
+				objectParam: {
+					foo: 'aaa',
+					bar: 'bbb',
+				},
+				arrayParam: [
+					{
+						foo: 'aaa',
+						bar: 'bbb',
+					},
+					{
+						foo: 'ccc',
+						bar: 'ddd',
+					},
+				],
+			})
+
+			const params = useRequestBody(ctx, {
+				stringParam: z.string(),
+				numberParam: z.number(),
+				booleanParam: z.boolean(),
+				objectParam: z.object({
+					foo: z.string(),
+					bar: z.string(),
+				}),
+				arrayParam: z.array(
+					z.object({
+						foo: z.string(),
+						bar: z.string(),
+					}),
+				),
+			})
+
+			expect(params.stringParam).toEqual('test_string')
+			expect(params.numberParam).toEqual(12)
+			expect(params.booleanParam).toEqual(true)
+			expect(params.objectParam).toEqual({ foo: 'aaa', bar: 'bbb' })
+			expect(params.arrayParam).toEqual([
+				{ foo: 'aaa', bar: 'bbb' },
+				{ foo: 'ccc', bar: 'ddd' },
+			])
+
+			expectTypeOf(params.stringParam).toEqualTypeOf<string>()
+			expectTypeOf(params.numberParam).toEqualTypeOf<number>()
+			expectTypeOf(params.booleanParam).toEqualTypeOf<boolean>()
+			expectTypeOf(params.objectParam).toEqualTypeOf<{ foo: string; bar: string }>()
+			expectTypeOf(params.arrayParam).toEqualTypeOf<{ foo: string; bar: string }[]>()
+		})
+
+		it('throws if a required param is missing', () => {
+			const ctx = mockContextBody(mockContext(), {
+				stringParam: 'test_string',
+			})
+
+			const test = () => {
+				useRequestBody(ctx, {
+					stringParam: z.string(),
+					numberParam: z.number(),
+				})
+			}
+
+			expect(test).toThrow(ValidationError)
+			expect(test).toThrow("Missing body params: 'numberParam'")
+		})
+
+		it('allows missing params when optional', () => {
+			const ctx = mockContextBody(mockContext(), {
+				stringParam: 'test_string',
+			})
+
+			const test = () => {
+				useRequestBody(ctx, {
+					stringParam: z.string(),
+					numberParam: z.number().optional(),
+				})
+			}
+
+			expect(test).not.toThrow(ValidationError)
+		})
+
+		it('infers the return type of optional params', () => {
+			const ctx = mockContextBody(mockContext(), {})
+
+			const params = useRequestBody(ctx, {
+				numberParam: z.number().optional(),
+			})
+
+			expectTypeOf(params.numberParam).toEqualTypeOf<number | undefined>()
+		})
+	})
 })