moonflower 1.2.0 → 1.3.0

package/src/openapi/analyzerModule/test/openApiAnalyzer.zod.spec.data.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod'
+import { z as valibot } from 'zod'
+
+import { usePathParams } from '../../../hooks/usePathParams'
+import { useRequestBody } from '../../../hooks/useRequestBody'
+import { Router } from '../../../router/Router'
+import { TestCase } from './TestCase'
+
+const router = new Router()
+
+router.post(`/test/${TestCase.parsesInlineZodNumber}/:id`, (ctx) => {
+	usePathParams(ctx, {
+		id: z.number(),
+	})
+
+	useRequestBody(ctx, {
+		data: z.number(),
+	})
+})
+
+router.post(`/test/${TestCase.parsesInlineZodString}/:id`, (ctx) => {
+	usePathParams(ctx, {
+		id: z.string(),
+	})
+
+	useRequestBody(ctx, {
+		data: z.string(),
+	})
+})
+
+router.post(`/test/${TestCase.parsesInlineZodObject}/:id`, (ctx) => {
+	usePathParams(ctx, {
+		id: z.object({
+			value: z.number(),
+		}),
+	})
+
+	useRequestBody(ctx, {
+		data: z.object({
+			value: z.number(),
+		}),
+	})
+})
+
+router.post(`/test/${TestCase.parsesInlineZodNumberArray}/:id`, (ctx) => {
+	usePathParams(ctx, {
+		id: z.array(z.number()),
+	})
+
+	useRequestBody(ctx, {
+		data: z.array(z.number()),
+	})
+})
+
+router.post(`/test/${TestCase.parsesInlineZodObjectArray}/:id`, (ctx) => {
+	usePathParams(ctx, {
+		id: z.array(
+			z.object({
+				value: z.number(),
+			}),
+		),
+	})
+
+	useRequestBody(ctx, {
+		data: z.array(
+			z.object({
+				value: z.number(),
+			}),
+		),
+	})
+})
+
+router.post(`/test/${TestCase.parsedAliasedZodSchema}/:id`, (ctx) => {
+	const schema = valibot.array(
+		valibot.object({
+			value: valibot.number(),
+		}),
+	)
+
+	usePathParams(ctx, {
+		id: schema,
+	})
+
+	useRequestBody(ctx, {
+		data: schema,
+	})
+})

package/src/openapi/analyzerModule/test/openApiAnalyzer.zod.spec.ts

@@ -0,0 +1,178 @@
+import { loadTestData } from '../../../utils/loadTestData'
+import { discoverRouters } from '../../discoveryModule/discoverRouters/discoverRouters'
+import { analyzeSourceFileEndpoints } from '../analyzerModule'
+import { TestCase } from './TestCase'
+
+describe('OpenApi Analyzer (Zod Validator)', () => {
+	describe('when analyzing a test data file', () => {
+		const dataFile = loadTestData('openApiAnalyzer.zod.spec.data.ts')
+		let analysisResult: ReturnType<typeof analyzeSourceFileEndpoints>
+
+		const analyzeEndpointById = (id: string) => {
+			analysisResult = analyzeSourceFileEndpoints(
+				{
+					fileName: 'test',
+					sourceFile: dataFile,
+					routers: discoverRouters(dataFile),
+				},
+				[`/test/${id}`],
+			)
+			const endpoint = analysisResult.find((endpoint) => endpoint.path.startsWith(`/test/${id}`))
+			if (!endpoint) {
+				throw new Error(`No endpoint with id ${id} found!`)
+			}
+			return endpoint
+		}
+
+		describe('zod validators', () => {
+			it('parses inline zod number validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesInlineZodNumber)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual('number')
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual('number')
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+
+			it('parses inline zod string validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesInlineZodString)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual('string')
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual('string')
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+
+			it('parses inline zod object validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesInlineZodObject)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual([
+					{
+						identifier: 'value',
+						optional: false,
+						role: 'property',
+						shape: 'number',
+					},
+				])
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual([
+					{
+						identifier: 'value',
+						optional: false,
+						role: 'property',
+						shape: 'number',
+					},
+				])
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+
+			it('parses inline zod number array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesInlineZodNumberArray)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'number',
+						optional: false,
+					},
+				])
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'number',
+						optional: false,
+					},
+				])
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+
+			it('parses inline zod object array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesInlineZodObjectArray)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: [
+							{
+								identifier: 'value',
+								optional: false,
+								role: 'property',
+								shape: 'number',
+							},
+						],
+						optional: false,
+					},
+				])
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: [
+							{
+								identifier: 'value',
+								optional: false,
+								role: 'property',
+								shape: 'number',
+							},
+						],
+						optional: false,
+					},
+				])
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+
+			it('parses aliased zod object array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsedAliasedZodSchema)
+
+				expect(endpoint.requestPathParams[0].identifier).toEqual('id')
+				expect(endpoint.requestPathParams[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: [
+							{
+								identifier: 'value',
+								optional: false,
+								role: 'property',
+								shape: 'number',
+							},
+						],
+						optional: false,
+					},
+				])
+				expect(endpoint.requestPathParams[0].optional).toEqual(false)
+
+				expect(endpoint.objectBody[0].identifier).toEqual('data')
+				expect(endpoint.objectBody[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: [
+							{
+								identifier: 'value',
+								optional: false,
+								role: 'property',
+								shape: 'number',
+							},
+						],
+						optional: false,
+					},
+				])
+				expect(endpoint.objectBody[0].optional).toEqual(false)
+			})
+		})
+	})
+})

package/src/utils/getValueAsNullableString.ts

@@ -0,0 +1,8 @@
+export function getValueAsNullableString(value: unknown) {
+	if (value === null) {
+		return null
+	} else if (typeof value === 'object') {
+		return JSON.stringify(value)
+	}
+	return String(value)
+}

package/src/utils/validationMessages.ts

@@ -30,10 +30,14 @@ export const getValidationResultMessage = (
 				originalName: string
 				validator: Pick<Validator<unknown>, 'description' | 'errorMessage'>
 		  },
+	exception?: string | null,
 ) => {
 	const name = 'name' in result ? result.name : result.originalName
 	const { description, errorMessage } = result.validator
 
+	if (exception) {
+		return `'${name}' (${exception})`
+	}
 	if (errorMessage) {
 		return `'${name}' (${errorMessage})`
 	}

package/src/validators/types.ts

@@ -1,3 +1,5 @@
+import z from 'zod'
+
 type DeepPartial<T> = {
 	[P in keyof T]?: T[P] extends Array<infer U>
 		? Array<DeepPartial<U>>
@@ -33,3 +35,6 @@ export type BuiltInValidator<T, DescriptionT extends string, ErrorMessageT exten
 	description: DescriptionT
 	errorMessage: ErrorMessageT
 }
+
+export type ValidatorUnion = Omit<Validator<any>, 'optional'> | z.ZodType
+export type MaybeOptionalValidatorUnion = Validator<any> | z.ZodType

package/src/validators/validateMissingParams.ts

@@ -0,0 +1,27 @@
+import z from 'zod'
+
+import { ValidationError } from '../errors/UserFacingErrors'
+import { getMissingParamMessage } from '../utils/validationMessages'
+import { MaybeOptionalValidatorUnion, Validator } from './types'
+
+export function validateMissingParams<ValidatorsT extends Record<string, MaybeOptionalValidatorUnion>>(
+	params: { name: string; validator: Pick<Validator<unknown>, 'description' | 'errorMessage'> }[],
+	providedParams: Record<string, unknown>,
+	validators: ValidatorsT,
+	suffix: 'body' | 'query' | 'path',
+) {
+	const missingParams = params.filter((param) => {
+		let isOptional = validators[param.name].optional
+		if (validators[param.name] instanceof z.ZodType) {
+			isOptional = (validators[param.name] as z.ZodType).safeParse(undefined).success
+		}
+
+		return providedParams[param.name] === undefined && !isOptional
+	})
+
+	if (missingParams.length > 0) {
+		throw new ValidationError(
+			`Missing ${suffix} params: ${missingParams.map((param) => getMissingParamMessage(param)).join(', ')}`,
+		)
+	}
+}

package/src/validators/validateParam.ts

@@ -0,0 +1,69 @@
+import z, { ZodError } from 'zod'
+
+import { getValueAsNullableString } from '../utils/getValueAsNullableString'
+import { ValidatorUnion } from './types'
+
+export function validateParam(
+	validator: ValidatorUnion,
+	value: string | number | boolean | object | null,
+): {
+	validated: boolean
+	parsedValue: unknown
+	exception: string | null
+} {
+	try {
+		const prevalidatorSuccess = runPrevalidator(validator, value)
+		const parsedValue = runParser(validator, value)
+		const validatorSuccess = runValidator(validator, parsedValue)
+
+		return {
+			validated: prevalidatorSuccess && validatorSuccess,
+			parsedValue,
+			exception: null,
+		}
+	} catch (error) {
+		const exception = getErrorMessage(error)
+		return { validated: false, parsedValue: null, exception }
+	}
+}
+
+function runPrevalidator(validator: ValidatorUnion, value: string | number | boolean | object | null) {
+	// Legacy validator
+	if ('prevalidate' in validator && typeof validator.prevalidate === 'function') {
+		return validator.prevalidate(getValueAsNullableString(value))
+	}
+	// Zod (skip)
+	return true
+}
+
+function runParser(validator: ValidatorUnion, value: string | number | boolean | object | null) {
+	// Zod validator
+	if (validator instanceof z.ZodType) {
+		const coercedValue = (() => {
+			try {
+				return typeof value === 'string' ? JSON.parse(value) : value
+			} catch {
+				return value
+			}
+		})()
+		return validator.parse(coercedValue)
+	}
+	// Legacy validator
+	return validator.parse(getValueAsNullableString(value))
+}
+
+function runValidator(validator: ValidatorUnion, parsedValue: unknown) {
+	// Legacy validator
+	if ('validate' in validator && typeof validator.validate === 'function') {
+		return validator.validate(parsedValue)
+	}
+	// Zod (skip)
+	return true
+}
+
+function getErrorMessage(error: unknown) {
+	if (error instanceof ZodError) {
+		return z.treeifyError(error).errors.join('; ').replace('Invalid input: ', '')
+	}
+	return 'Validation failed'
+}