moonflower 0.9.0

package/src/hooks/useRequestBody.spec.ts

@@ -0,0 +1,215 @@
+import {
+	BooleanValidator,
+	NumberValidator,
+	OptionalParam,
+	RequiredParam,
+	StringValidator,
+	useRequestBody,
+	ValidationError,
+} from '..'
+import { mockContext, mockContextBody } from '../utils/mockContext'
+
+describe('useRequestBody', () => {
+	it('parses params correctly', () => {
+		const ctx = mockContextBody(mockContext(), {
+			stringParam: 'test_string',
+			numberParam: '12',
+			booleanParam: 'true',
+			objectParam: {
+				foo: 'aaa',
+				bar: 'bbb',
+			},
+		})
+
+		const params = useRequestBody(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 = mockContextBody(mockContext(), {
+			testParam: '12',
+		})
+
+		const params = useRequestBody(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(12)
+	})
+
+	it('passes validation on numeric zero parameter', () => {
+		const ctx = mockContextBody(mockContext(), {
+			testParam: 0,
+		})
+
+		const params = useRequestBody(ctx, {
+			testParam: NumberValidator,
+		})
+
+		expect(params.testParam).toEqual(0)
+	})
+
+	it('fails validation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextBody(mockContext(), {
+				testParam: 'qwerty',
+			})
+
+			useRequestBody(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed body param validation: 'testParam'")
+	})
+
+	it('passes validation for nullable parameter', () => {
+		const ctx = mockContextBody(mockContext(), {
+			testParam: null,
+		})
+
+		const params = useRequestBody(ctx, {
+			testParam: RequiredParam({
+				parse: (v) => v,
+				validate: (v) => v === null,
+			}),
+		})
+
+		expect(params.testParam).toEqual(null)
+	})
+
+	it('passes validation when optional parameter is not provided', () => {
+		const ctx = mockContextBody(mockContext(), {})
+
+		const params = useRequestBody(ctx, {
+			testParam: OptionalParam(NumberValidator),
+		})
+
+		expect(params.testParam).toEqual(undefined)
+	})
+
+	it('fails validation when required parameter is not provided', () => {
+		const test = () => {
+			const ctx = mockContextBody(mockContext(), {})
+
+			useRequestBody(ctx, {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Missing body params: 'testParam'")
+	})
+
+	it('fails validation when no body is provided at all', () => {
+		const test = () => {
+			useRequestBody(mockContext(), {
+				testParam: NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Missing body params: 'testParam'")
+	})
+
+	it('passes prevalidation on valid parameter', () => {
+		const ctx = mockContextBody(mockContext(), {
+			testParam: 'valid',
+		})
+
+		const params = useRequestBody(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 = mockContextBody(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useRequestBody(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed body param validation: 'testParam'")
+	})
+
+	it('fails prevalidation on parse error', () => {
+		const test = () => {
+			const ctx = mockContextBody(mockContext(), {
+				testParam: 'not a json',
+			})
+
+			useRequestBody(ctx, {
+				testParam: RequiredParam<{ foo: 'aaa' }>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed body param validation: 'testParam'")
+	})
+
+	it('sends an error message when validation fails', () => {
+		const test = () => {
+			const ctx = mockContextBody(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useRequestBody(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+					errorMessage: 'Error message',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed body param validation: 'testParam' (Error message)")
+	})
+
+	it('sends the description when validation fails with no error message provided', () => {
+		const test = () => {
+			const ctx = mockContextBody(mockContext(), {
+				testParam: 'invalid',
+			})
+
+			useRequestBody(ctx, {
+				testParam: RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed body param validation: 'testParam' (Description)")
+	})
+})

package/src/hooks/useRequestBody.ts

@@ -0,0 +1,94 @@
+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
+
+type ValidatedData<T extends Record<string, Validator<any>>> = {
+	[K in keyof T]: CheckIfOptional<ReturnType<T[K]['parse']>, T[K]['optional']>
+}
+
+/**
+ * Hook to access request body data in JSON or form formats.
+ *
+ * Supported content types:
+ * - `application/json`
+ * - `application/x-www-form-urlencoded`
+ *
+ * @param ctx Koa context
+ * @param validators Validator definitions
+ * @returns Validated parameters
+ */
+export const useRequestBody = <ValidatorsT extends Record<string, Validator<any>>>(
+	ctx: ParameterizedContext,
+	validators: ValidatorsT
+): ValidatedData<ValidatorsT> => {
+	const providedParams = (ctx.request.body || {}) as Record<string, string | number | boolean | object>
+	const params = keysOf(validators).map((name) => ({
+		name,
+		validator: validators[name],
+	}))
+
+	const missingParams = params.filter(
+		(param) => providedParams[param.name] === undefined && !validators[param.name].optional
+	)
+
+	if (missingParams.length > 0) {
+		throw new ValidationError(
+			`Missing body params: ${missingParams.map((param) => getMissingParamMessage(param)).join(', ')}`
+		)
+	}
+
+	const validationResults = params.map((param) => {
+		const paramValue = providedParams[param.name]
+
+		// Param is optional and is not provided - skip validation
+		if (paramValue === undefined) {
+			return { param, validated: true }
+		}
+
+		try {
+			const convertedValue = (() => {
+				if (paramValue === null) {
+					return null
+				} else if (typeof paramValue === 'object') {
+					return JSON.stringify(paramValue)
+				}
+				return String(paramValue)
+			})()
+			const validatorObject = param.validator
+			const prevalidatorSuccess = !validatorObject.prevalidate || validatorObject.prevalidate(convertedValue)
+			const parsedValue = validatorObject.parse(convertedValue)
+			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 body 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>
+}

package/src/hooks/useRequestRawBody.spec.ts

@@ -0,0 +1,154 @@
+import { NumberValidator, OptionalParam, RequiredParam, useRequestRawBody, ValidationError } from '..'
+import { mockContext, mockContextBody, mockContextRawBody } from '../utils/mockContext'
+
+describe('useRequestRawBody', () => {
+	it('parses param correctly', () => {
+		const ctx = mockContextBody(mockContext(), {
+			foo: 'aaa',
+			bar: 'bbb',
+		})
+
+		const params = useRequestRawBody(
+			ctx,
+			RequiredParam<{ foo: string; bar: string }>({
+				parse: (v) => JSON.parse(String(v)),
+			})
+		)
+
+		expect(params.foo).toEqual('aaa')
+		expect(params.bar).toEqual('bbb')
+	})
+
+	it('passes validation on valid parameter', () => {
+		const ctx = mockContextRawBody(mockContext(), '12')
+
+		const rawBody = useRequestRawBody(ctx, NumberValidator)
+
+		expect(rawBody).toEqual(12)
+	})
+
+	it('fails validation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextRawBody(mockContext(), 'not a number')
+
+			useRequestRawBody(ctx, NumberValidator)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Failed request body validation (Must be a valid number).')
+	})
+
+	it('passes validation when optional parameter is not provided', () => {
+		const params = useRequestRawBody(mockContext(), OptionalParam(NumberValidator))
+
+		expect(params).toEqual(undefined)
+	})
+
+	it('fails validation when required parameter is not provided', () => {
+		const test = () => {
+			useRequestRawBody(mockContext(), NumberValidator)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Missing request body (Any numeric value).')
+	})
+
+	it('fails validation for inline validator', () => {
+		const test = () => {
+			useRequestRawBody(
+				mockContext(),
+				RequiredParam({
+					parse: (v) => Number(v),
+					validate: (v) => !Number.isNaN(v),
+				})
+			)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Missing request body.')
+	})
+
+	it('passes prevalidation on valid parameter', () => {
+		const ctx = mockContextRawBody(mockContext(), 'valid')
+
+		const params = useRequestRawBody(
+			ctx,
+			RequiredParam({
+				prevalidate: (v) => v === 'valid',
+				parse: (v) => String(v),
+			})
+		)
+
+		expect(params).toEqual('valid')
+	})
+
+	it('fails prevalidation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextRawBody(mockContext(), 'invalid')
+
+			useRequestRawBody(
+				ctx,
+				RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+				})
+			)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Failed request body validation.')
+	})
+
+	it('fails prevalidation on parse error', () => {
+		const test = () => {
+			const ctx = mockContextRawBody(mockContext(), 'not a valid json')
+
+			useRequestRawBody(
+				ctx,
+				RequiredParam<{ foo: 'aaa' }>({
+					parse: (v) => JSON.parse(String(v)),
+				})
+			)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Failed request body validation.')
+	})
+
+	it('sends an error message when validation fails', () => {
+		const test = () => {
+			const ctx = mockContextRawBody(mockContext(), 'invalid')
+
+			useRequestRawBody(
+				ctx,
+				RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+					errorMessage: 'Error message',
+				})
+			)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Failed request body validation (Error message).')
+	})
+
+	it('sends the description when validation fails with no error message provided', () => {
+		const test = () => {
+			const ctx = mockContextRawBody(mockContext(), 'invalid')
+
+			useRequestRawBody(
+				ctx,
+				RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+				})
+			)
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow('Failed request body validation (Description).')
+	})
+})

package/src/hooks/useRequestRawBody.ts

@@ -0,0 +1,56 @@
+import { ParameterizedContext } from 'koa'
+
+import { ValidationError } from '../errors/UserFacingErrors'
+import { getFailedRawBodyValidationMessage, getMissingRawBodyMessage } 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 Validator<any>> = CheckIfOptional<ReturnType<T['parse']>, T['optional']>
+
+/**
+ * Hook to access request body data without parsing into an object.
+ *
+ * Supported content types:
+ * - `text/plain`
+ * - `application/json`
+ * - `application/x-www-form-urlencoded`
+ *
+ * @param ctx Koa context
+ * @param validators Validator definitions
+ * @returns Validated parameters
+ */
+export const useRequestRawBody = <ValidatorT extends Validator<any>>(
+	ctx: ParameterizedContext,
+	validator: ValidatorT
+): ValidatedData<ValidatorT> => {
+	const providedBody = ctx.request.rawBody
+	const isOptional = validator.optional
+
+	if (!isOptional && !providedBody) {
+		throw new ValidationError(getMissingRawBodyMessage(validator))
+	}
+
+	if (isOptional && !providedBody) {
+		return undefined as ValidatedData<ValidatorT>
+	}
+
+	const validationResult = (() => {
+		try {
+			const prevalidatorSuccess = !validator.prevalidate || validator.prevalidate(providedBody)
+			const parsedValue = validator.parse(providedBody)
+			const validatorSuccess = !validator.validate || validator.validate(parsedValue)
+			return {
+				validated: prevalidatorSuccess && validatorSuccess,
+				parsedValue,
+			}
+		} catch (error) {
+			return { validated: false }
+		}
+	})()
+
+	if (!validationResult.validated) {
+		throw new ValidationError(getFailedRawBodyValidationMessage(validator))
+	}
+	return validationResult.parsedValue as ValidatedData<ValidatorT>
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from './errors/HttpErrorHandler'
+export * from './errors/UserFacingErrors'
+export * from './hooks/authentication/useAuth'
+export * from './hooks/authentication/useOptionalAuth'
+export * from './hooks/useApiEndpoint'
+export * from './hooks/useApiHeader/useApiHeader'
+export * from './hooks/useCookieParams'
+export * from './hooks/useExposeApiModel'
+export * from './hooks/useHeaderParams'
+export * from './hooks/usePathParams'
+export * from './hooks/useQueryParams'
+export * from './hooks/useRequestBody'
+export * from './hooks/useRequestRawBody'
+export * from './openapi/initOpenApiEngine'
+export * from './router/Router'
+export * from './validators/BuiltInValidators'
+export * from './validators/ParamWrappers'