moonflower 0.9.0

package/src/hooks/usePathParams.spec.ts

@@ -0,0 +1,161 @@
+import {
+	BooleanValidator,
+	NumberValidator,
+	PathParam,
+	RequiredParam,
+	StringValidator,
+	ValidationError,
+} from '..'
+import { mockContext, mockContextPath } from '../utils/mockContext'
+import { usePathParams } from './usePathParams'
+
+describe('usePathParams', () => {
+	it('parses params correctly', () => {
+		const ctx = mockContextPath(mockContext(), '/test/:stringParam/:numberParam/:booleanParam/:objectParam', {
+			stringParam: 'test_string',
+			numberParam: '12',
+			booleanParam: 'true',
+			objectParam: '{ "foo": "aaa", "bar": "bbb" }',
+		})
+
+		const params = usePathParams(ctx, {
+			stringParam: StringValidator,
+			numberParam: NumberValidator,
+			booleanParam: BooleanValidator,
+			objectParam: RequiredParam<{ foo: string; bar: string }>({
+				parse: (v) => JSON.parse(String(v)),
+			}),
+		})
+
+		expect(params.stringParam).toEqual('test_string')
+		expect(params.numberParam).toEqual(12)
+		expect(params.booleanParam).toEqual(true)
+		expect(params.objectParam).toEqual({ foo: 'aaa', bar: 'bbb' })
+	})
+
+	it('passes validation on valid parameter', () => {
+		const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+			testParam: '12',
+		})
+
+		const params = usePathParams(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(12)
+	})
+
+	it('fails validation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+				testParam: 'qwerty',
+			})
+
+			usePathParams(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed route param validation: 'testParam'")
+	})
+
+	it('passes validation when optional parameter is not provided', () => {
+		const ctx = mockContextPath(mockContext(), '/test/:testParam?', {})
+
+		const params = usePathParams(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(undefined)
+	})
+
+	it('passes prevalidation on valid parameter', () => {
+		const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+			testParam: 'valid',
+		})
+
+		const params = usePathParams(ctx, {
+			testParam: PathParam({
+				prevalidate: (v) => v === 'valid',
+				parse: (v) => String(v),
+			}),
+		})
+
+		expect(params.testParam).toEqual('valid')
+	})
+
+	it('fails prevalidation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+				testParam: 'invalid',
+			})
+
+			usePathParams(ctx, {
+				testParam: PathParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed route param validation: 'testParam'")
+	})
+
+	it('fails prevalidation on parse error', () => {
+		const test = () => {
+			const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+				testParam: 'not a json',
+			})
+
+			usePathParams(ctx, {
+				testParam: PathParam<{ foo: 'aaa' }>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed route param validation: 'testParam'")
+	})
+
+	it('sends an error message when validation fails', () => {
+		const test = () => {
+			const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+				testParam: 'invalid',
+			})
+
+			usePathParams(ctx, {
+				testParam: PathParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+					errorMessage: 'Error message',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed route param validation: 'testParam' (Error message)")
+	})
+
+	it('sends the description when validation fails with no error message provided', () => {
+		const test = () => {
+			const ctx = mockContextPath(mockContext(), '/test/:testParam', {
+				testParam: 'invalid',
+			})
+
+			usePathParams(ctx, {
+				testParam: PathParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed route param validation: 'testParam' (Description)")
+	})
+})

package/src/hooks/usePathParams.ts

@@ -0,0 +1,89 @@
+import { ParameterizedContext } from 'koa'
+
+import { ValidationError } from '../errors/UserFacingErrors'
+import { keysOf } from '../utils/object'
+import { CleanUpPathParam } from '../utils/TypeUtils'
+import { getValidationResultMessage } from '../utils/validationMessages'
+import { Validator } from '../validators/types'
+
+type CheckIfOptional<T, B> = B extends string ? (B extends `${string}?` ? T | undefined : T) : never
+
+type ValidatedData<
+	ParamsT extends string[],
+	TestTemplate extends {
+		[K in keyof ParamsT]: {
+			original: ParamsT[K]
+			cleaned: CleanUpPathParam<ParamsT[K]>
+			callback: ValidatorsT[CleanUpPathParam<ParamsT[K]>]
+		}
+	},
+	ValidatorsT extends Record<TestTemplate[number]['cleaned'], Omit<Validator<any>, 'optional'>>
+> = {
+	[K in keyof TestTemplate as K extends `${number}` ? TestTemplate[K]['cleaned'] : never]: CheckIfOptional<
+		ReturnType<TestTemplate[K]['callback']['parse']>,
+		TestTemplate[K]['original']
+	>
+}
+
+export const usePathParams = <
+	ParamsT extends string[],
+	TestTemplate extends {
+		[K in keyof ParamsT]: {
+			original: ParamsT[K]
+			cleaned: CleanUpPathParam<ParamsT[K]>
+			callback: ValidatorsT[CleanUpPathParam<ParamsT[K]>]
+		}
+	},
+	ValidatorsT extends Record<CleanUpPathParam<ParamsT[number]>, Omit<Validator<any>, 'optional'>>
+>(
+	ctx: ParameterizedContext & { parsedPathParams: ParamsT },
+	validators: ValidatorsT
+): ValidatedData<ParamsT, TestTemplate, ValidatorsT> => {
+	const params = ctx.params
+	const expectedParams = keysOf(validators).map((name) => ({
+		name,
+		validator: validators[name],
+	}))
+
+	const validationResults = expectedParams.map((param) => {
+		const paramValue = params[param.name] as string
+
+		// Param is optional and is not provided - skip validation
+		if (paramValue === undefined) {
+			return { param, validated: true }
+		}
+
+		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 (error) {
+			return { param, validated: false }
+		}
+	})
+
+	const failedValidations = validationResults.filter((result) => !result.validated)
+
+	if (failedValidations.length > 0) {
+		throw new ValidationError(
+			`Failed route param validation: ${failedValidations
+				.map((result) => getValidationResultMessage(result.param))
+				.join(', ')}`
+		)
+	}
+
+	const successfulValidations = validationResults.filter((result) => result.validated)
+
+	const returnValue: Record<string, unknown> = {}
+	successfulValidations.forEach((result) => {
+		returnValue[result.param.name] = result.parsedValue
+	})
+
+	return returnValue as ValidatedData<ParamsT, TestTemplate, ValidatorsT>
+}

package/src/hooks/useQueryParams.spec.ts

@@ -0,0 +1,224 @@
+import {
+	BigIntValidator,
+	BooleanValidator,
+	NumberValidator,
+	OptionalParam,
+	RequiredParam,
+	StringValidator,
+	useQueryParams,
+	ValidationError,
+} from '..'
+import { mockContext, mockContextQuery } from '../utils/mockContext'
+
+describe('useQueryParams', () => {
+	it('parses params correctly', () => {
+		const ctx = mockContextQuery(mockContext(), {
+			stringParam: 'test_string',
+			numberParam: '12',
+			booleanParam: 'true',
+			objectParam: '{ "foo": "aaa", "bar": "bbb" }',
+		})
+
+		const params = useQueryParams(ctx, {
+			stringParam: StringValidator,
+			numberParam: NumberValidator,
+			booleanParam: BooleanValidator,
+			objectParam: RequiredParam<{ foo: string; bar: string }>({
+				parse: (v) => JSON.parse(String(v)),
+			}),
+		})
+
+		expect(params.stringParam).toEqual('test_string')
+		expect(params.numberParam).toEqual(12)
+		expect(params.booleanParam).toEqual(true)
+		expect(params.objectParam).toEqual({ foo: 'aaa', bar: 'bbb' })
+	})
+
+	it('passes validation on valid parameter', () => {
+		const ctx = mockContextQuery(mockContext(), {
+			testParam: '12',
+		})
+
+		const params = useQueryParams(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(12)
+	})
+
+	it('fails validation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: 'qwerty',
+			})
+
+			useQueryParams(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam'")
+	})
+
+	it('passes validation on large number', () => {
+		const reallyBigNumber = `1${Array(100)
+			.fill('0')
+			.reduce((total, current) => total + current, '')}`
+		const ctx = mockContextQuery(mockContext(), {
+			testParam: reallyBigNumber,
+		})
+
+		const params = useQueryParams(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(1e100)
+	})
+
+	it('fails validation on number being too large', () => {
+		const test = () => {
+			const reallyBigNumber = `1${Array(500)
+				.fill('0')
+				.reduce((total, current) => total + current, '')}`
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: reallyBigNumber,
+			})
+
+			useQueryParams(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam'")
+	})
+
+	it('passes validation on very large biging', () => {
+		const reallyBigNumber = `1${Array(1000)
+			.fill('0')
+			.reduce((total, current) => total + current, '')}`
+		const ctx = mockContextQuery(mockContext(), {
+			testParam: reallyBigNumber,
+		})
+
+		const params = useQueryParams(ctx, {
+			testParam: BigIntValidator,
+		})
+
+		const expectedBigInt = BigInt(reallyBigNumber)
+		expect(params.testParam).toEqual(expectedBigInt)
+	})
+
+	it('passes validation when optional parameter is not provided', () => {
+		const ctx = mockContextQuery(mockContext(), {})
+
+		const params = useQueryParams(ctx, {
+			testParam: OptionalParam(NumberValidator),
+		})
+
+		expect(params.testParam).toEqual(undefined)
+	})
+
+	it('fails validation when required parameter is not provided', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {})
+
+			useQueryParams(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Missing query params: 'testParam'")
+	})
+
+	it('passes prevalidation on valid parameter', () => {
+		const ctx = mockContextQuery(mockContext(), {
+			testParam: 'valid',
+		})
+
+		const params = useQueryParams(ctx, {
+			testParam: RequiredParam({
+				prevalidate: (v) => v === 'valid',
+				parse: (v) => String(v),
+			}),
+		})
+
+		expect(params.testParam).toEqual('valid')
+	})
+
+	it('fails prevalidation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useQueryParams(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam'")
+	})
+
+	it('fails prevalidation on parse error', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: 'not a json',
+			})
+
+			useQueryParams(ctx, {
+				testParam: RequiredParam<{ foo: 'aaa' }>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam'")
+	})
+
+	it('sends an error message when validation fails', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useQueryParams(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+					errorMessage: 'Error message',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam' (Error message)")
+	})
+
+	it('sends the description when validation fails with no error message provided', () => {
+		const test = () => {
+			const ctx = mockContextQuery(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useQueryParams(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed query param validation: 'testParam' (Description)")
+	})
+})

package/src/hooks/useQueryParams.ts

@@ -0,0 +1,73 @@
+import { ParameterizedContext } from 'koa'
+
+import { ValidationError } from '../errors/UserFacingErrors'
+import { keysOf } from '../utils/object'
+import { getMissingParamMessage, getValidationResultMessage } from '../utils/validationMessages'
+import { Validator } from '../validators/types'
+
+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']>
+}
+
+export const useQueryParams = <ValidatorsT extends Record<string, Validator<any>>>(
+	ctx: ParameterizedContext,
+	validators: ValidatorsT
+): ValidatedData<ValidatorsT> => {
+	const query = ctx.query
+	const params = keysOf(validators).map((name) => ({
+		name,
+		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(', ')}`
+		)
+	}
+
+	const validationResults = params.map((param) => {
+		const paramValue = query[param.name] as string
+
+		// Param is optional and is not provided - skip validation
+		if (paramValue === undefined) {
+			return { param, validated: true }
+		}
+
+		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 (error) {
+			return { param, validated: false }
+		}
+	})
+
+	const failedValidations = validationResults.filter((result) => !result.validated)
+
+	if (failedValidations.length > 0) {
+		throw new ValidationError(
+			`Failed query param validation: ${failedValidations
+				.map((result) => getValidationResultMessage(result.param))
+				.join(', ')}`
+		)
+	}
+
+	const successfulValidations = validationResults.filter((result) => result.validated)
+
+	const returnValue: Record<string, unknown> = {}
+	successfulValidations.forEach((result) => {
+		returnValue[result.param.name] = result.parsedValue
+	})
+
+	return returnValue as ValidatedData<ValidatorsT>
+}