moonflower 0.9.0

package/src/hooks/useExposeApiModel/useExposeApiModel.spec.data.ts

@@ -0,0 +1,48 @@
+import { useExposeApiModel, useExposeNamedApiModels } from './useExposeApiModel'
+
+type FooBarObject = {
+	foo: string
+	bar: number
+	baz: boolean
+}
+
+useExposeApiModel<FooBarObject>()
+useExposeNamedApiModels<{
+	SimpleString: string
+	SimpleNumber: number
+	SimpleBoolean: boolean
+	NumberBase: 'foo' | 'bar'
+}>()
+
+type OptionalFooObject = Partial<Pick<FooBarObject, 'foo'>>
+useExposeApiModel<OptionalFooObject>()
+
+type UnionWithTuple = { fff: string | [string, string, string] }
+useExposeApiModel<UnionWithTuple>()
+
+type NumberBase = 'dec' | 'hex' | 'bin'
+
+type ModelWithPrimitiveRecord = {
+	key: Record<string, number>
+}
+useExposeApiModel<ModelWithPrimitiveRecord>()
+
+type ModelWithSimpleRecord = {
+	key: Record<NumberBase, number>
+}
+useExposeApiModel<ModelWithSimpleRecord>()
+
+type ModelWithComplexRecord = {
+	key: Record<NumberBase, NumberBase>
+}
+useExposeApiModel<ModelWithComplexRecord>()
+
+const modelAsObject = {
+	foo: '123',
+	bar: 123,
+}
+useExposeApiModel<typeof modelAsObject>
+
+useExposeNamedApiModels<{
+	RenamedModelAsObject: typeof modelAsObject
+}>

package/src/hooks/useExposeApiModel/useExposeApiModel.spec.ts

@@ -0,0 +1,388 @@
+import { analyzeSourceFileExposedModels } from '../../openapi/analyzerModule/analyzerModule'
+import { loadTestData } from '../../utils/loadTestData'
+import { useExposeApiModel, useExposeNamedApiModels } from './useExposeApiModel'
+
+describe('useExposeApiModel', () => {
+	describe('when analyzing a test data file', () => {
+		const dataFile = loadTestData('useExposeApiModel.spec.data.ts')
+		let analysisResult: ReturnType<typeof analyzeSourceFileExposedModels>
+
+		const analyzeModelByName = (name: string) => {
+			if (!analysisResult) {
+				analysisResult = analyzeSourceFileExposedModels(dataFile)
+			}
+			const exposedModel = analysisResult.find((model) => model.name === name)
+			if (!exposedModel) {
+				throw new Error(`No exposed model with name ${name} found!`)
+			}
+			return exposedModel
+		}
+
+		it('does not have side effects when invoked directly', () => {
+			useExposeApiModel()
+			useExposeNamedApiModels()
+		})
+
+		it('parses single expose model correctly', () => {
+			const model = analyzeModelByName('FooBarObject')
+
+			expect(model.shape).toEqual([
+				{
+					role: 'property',
+					identifier: 'foo',
+					shape: 'string',
+					optional: false,
+				},
+				{
+					role: 'property',
+					identifier: 'bar',
+					shape: 'number',
+					optional: false,
+				},
+				{
+					role: 'property',
+					identifier: 'baz',
+					shape: 'boolean',
+					optional: false,
+				},
+			])
+		})
+
+		it('parses named exposed models correctly', () => {
+			const simpleStringModel = analyzeModelByName('SimpleString')
+			const simpleNumberModel = analyzeModelByName('SimpleNumber')
+			const numberBaseModel = analyzeModelByName('NumberBase')
+
+			expect(simpleStringModel.shape).toEqual('string')
+			expect(simpleNumberModel.shape).toEqual('number')
+			expect(numberBaseModel.shape).toEqual([
+				{
+					role: 'union',
+					optional: false,
+					shape: [
+						{
+							role: 'union_entry',
+							optional: false,
+							shape: [{ optional: false, role: 'literal_string', shape: 'foo' }],
+						},
+						{
+							role: 'union_entry',
+							optional: false,
+							shape: [{ optional: false, role: 'literal_string', shape: 'bar' }],
+						},
+					],
+				},
+			])
+		})
+
+		it('parses model with type utilities correctly', () => {
+			const optionalFooObject = analyzeModelByName('OptionalFooObject')
+
+			expect(optionalFooObject).toEqual({
+				name: 'OptionalFooObject',
+				shape: [{ identifier: 'foo', optional: true, role: 'property', shape: 'string' }],
+			})
+		})
+
+		it('parses model with tuple correctly', () => {
+			const unionWithTupleObject = analyzeModelByName('UnionWithTuple')
+
+			expect(unionWithTupleObject).toEqual({
+				name: 'UnionWithTuple',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'fff',
+						shape: [
+							{
+								role: 'union',
+								shape: [
+									{ role: 'union_entry', shape: 'string', optional: false },
+									{
+										role: 'union_entry',
+										shape: [
+											{
+												role: 'tuple',
+												shape: [
+													{
+														role: 'tuple_entry',
+														shape: 'string',
+														optional: false,
+													},
+													{
+														role: 'tuple_entry',
+														shape: 'string',
+														optional: false,
+													},
+													{
+														role: 'tuple_entry',
+														shape: 'string',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+										],
+										optional: false,
+									},
+								],
+								optional: false,
+							},
+						],
+						optional: false,
+					},
+				],
+			})
+		})
+
+		it('parses model with primitive Record correctly', () => {
+			const modelWithRecord = analyzeModelByName('ModelWithPrimitiveRecord')
+
+			expect(modelWithRecord).toEqual({
+				name: 'ModelWithPrimitiveRecord',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'key',
+						shape: [{ role: 'record', shape: 'number', optional: false }],
+						optional: false,
+					},
+				],
+			})
+		})
+
+		it('parses model with simple Record correctly', () => {
+			const modelWithRecord = analyzeModelByName('ModelWithSimpleRecord')
+
+			expect(modelWithRecord).toEqual({
+				name: 'ModelWithSimpleRecord',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'key',
+						shape: [
+							{
+								role: 'property',
+								identifier: 'dec',
+								shape: 'number',
+								optional: false,
+							},
+							{
+								role: 'property',
+								identifier: 'hex',
+								shape: 'number',
+								optional: false,
+							},
+							{
+								role: 'property',
+								identifier: 'bin',
+								shape: 'number',
+								optional: false,
+							},
+						],
+						optional: false,
+					},
+				],
+			})
+		})
+
+		it('parses model with complex Record correctly', () => {
+			const modelWithRecord = analyzeModelByName('ModelWithComplexRecord')
+
+			expect(modelWithRecord).toEqual({
+				name: 'ModelWithComplexRecord',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'key',
+						shape: [
+							{
+								role: 'property',
+								identifier: 'dec',
+								shape: [
+									{
+										role: 'union',
+										shape: [
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'dec',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'hex',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'bin',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+										],
+										optional: false,
+									},
+								],
+								optional: false,
+							},
+							{
+								role: 'property',
+								identifier: 'hex',
+								shape: [
+									{
+										role: 'union',
+										shape: [
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'dec',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'hex',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'bin',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+										],
+										optional: false,
+									},
+								],
+								optional: false,
+							},
+							{
+								role: 'property',
+								identifier: 'bin',
+								shape: [
+									{
+										role: 'union',
+										shape: [
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'dec',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'hex',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+											{
+												role: 'union_entry',
+												shape: [
+													{
+														role: 'literal_string',
+														shape: 'bin',
+														optional: false,
+													},
+												],
+												optional: false,
+											},
+										],
+										optional: false,
+									},
+								],
+								optional: false,
+							},
+						],
+						optional: false,
+					},
+				],
+			})
+		})
+
+		it('parses model defined with typeof expression', () => {
+			const modelWithRecord = analyzeModelByName('modelAsObject')
+
+			expect(modelWithRecord).toEqual({
+				name: 'modelAsObject',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'foo',
+						shape: 'string',
+						optional: false,
+					},
+					{
+						role: 'property',
+						identifier: 'bar',
+						shape: 'number',
+						optional: false,
+					},
+				],
+			})
+		})
+
+		it('parses named model defined with typeof expression', () => {
+			const modelWithRecord = analyzeModelByName('RenamedModelAsObject')
+
+			expect(modelWithRecord).toEqual({
+				name: 'RenamedModelAsObject',
+				shape: [
+					{
+						role: 'property',
+						identifier: 'foo',
+						shape: 'string',
+						optional: false,
+					},
+					{
+						role: 'property',
+						identifier: 'bar',
+						shape: 'number',
+						optional: false,
+					},
+				],
+			})
+		})
+	})
+})

package/src/hooks/useExposeApiModel/useExposeApiModel.ts

@@ -0,0 +1,9 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const useExposeApiModel = <_T>() => {
+	// Empty
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const useExposeNamedApiModels = <_T extends Record<string, any>>() => {
+	// Empty
+}

package/src/hooks/useHeaderParams.spec.ts

@@ -0,0 +1,186 @@
+import {
+	BooleanValidator,
+	NumberValidator,
+	OptionalParam,
+	RequiredParam,
+	StringValidator,
+	useHeaderParams,
+	ValidationError,
+} from '..'
+import { mockContext, mockContextHeaders } from '../utils/mockContext'
+
+describe('useHeaderParams', () => {
+	it('parses params correctly', () => {
+		const ctx = mockContextHeaders(mockContext(), {
+			'string-header': 'test_string',
+			'number-header': '12',
+			'boolean-header': 'true',
+			'object-header': '{ "foo": "aaa", "bar": "bbb" }',
+		})
+
+		const params = useHeaderParams(ctx, {
+			'string-header': StringValidator,
+			'number-header': NumberValidator,
+			'boolean-header': BooleanValidator,
+			'object-header': RequiredParam<{ foo: string; bar: string }>({
+				parse: (v) => JSON.parse(String(v)),
+			}),
+		})
+
+		expect(params.stringHeader).toEqual('test_string')
+		expect(params.numberHeader).toEqual(12)
+		expect(params.booleanHeader).toEqual(true)
+		expect(params.objectHeader).toEqual({ foo: 'aaa', bar: 'bbb' })
+	})
+
+	it('parses camelCase params with camelCase headers correctly', () => {
+		const ctx = mockContextHeaders(mockContext(), {
+			stringheader: 'test_string',
+		})
+
+		const params = useHeaderParams(ctx, {
+			stringHeader: StringValidator,
+		})
+
+		expect(params.stringHeader).toEqual('test_string')
+	})
+
+	it('passes validation on valid parameter', () => {
+		const ctx = mockContextHeaders(mockContext(), {
+			'test-header': '12',
+		})
+
+		const params = useHeaderParams(ctx, {
+			'test-header': NumberValidator,
+		})
+
+		expect(params.testHeader).toEqual(12)
+	})
+
+	it('fails validation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {
+				'test-header': 'qwerty',
+			})
+
+			useHeaderParams(ctx, {
+				'test-header': NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed header validation: 'test-header'")
+	})
+
+	it('passes validation when optional parameter is not provided', () => {
+		const ctx = mockContextHeaders(mockContext(), {})
+
+		const params = useHeaderParams(ctx, {
+			'test-header': OptionalParam(NumberValidator),
+		})
+
+		expect(params.testHeader).toEqual(undefined)
+	})
+
+	it('fails validation when required parameter is not provided', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {})
+
+			useHeaderParams(ctx, {
+				'test-header': NumberValidator,
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Missing headers: 'test-header'")
+	})
+
+	it('passes prevalidation on valid parameter', () => {
+		const ctx = mockContextHeaders(mockContext(), {
+			'test-header': 'valid',
+		})
+
+		const params = useHeaderParams(ctx, {
+			'test-header': RequiredParam({
+				prevalidate: (v) => v === 'valid',
+				parse: (v) => String(v),
+			}),
+		})
+
+		expect(params.testHeader).toEqual('valid')
+	})
+
+	it('fails prevalidation on invalid parameter', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {
+				'test-header': 'invalid',
+			})
+
+			useHeaderParams(ctx, {
+				'test-header': RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed header validation: 'test-header'")
+	})
+
+	it('fails prevalidation on parse error', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {
+				'test-header': 'not a json',
+			})
+
+			useHeaderParams(ctx, {
+				'test-header': RequiredParam<{ foo: 'aaa' }>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed header validation: 'test-header'")
+	})
+
+	it('sends an error message when validation fails', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {
+				'test-header': 'invalid',
+			})
+
+			useHeaderParams(ctx, {
+				'test-header': RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+					errorMessage: 'Error message',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed header validation: 'test-header' (Error message)")
+	})
+
+	it('sends the description when validation fails with no error message provided', () => {
+		const test = () => {
+			const ctx = mockContextHeaders(mockContext(), {
+				'test-header': 'invalid',
+			})
+
+			useHeaderParams(ctx, {
+				'test-header': RequiredParam({
+					prevalidate: (v) => v === 'valid',
+					parse: (v) => String(v),
+					description: 'Description',
+				}),
+			})
+		}
+
+		expect(test).toThrow(ValidationError)
+		expect(test).toThrow("Failed header validation: 'test-header' (Description)")
+	})
+})

package/src/hooks/useHeaderParams.ts

@@ -0,0 +1,83 @@
+import { ParameterizedContext } from 'koa'
+
+import { ValidationError } from '../errors/UserFacingErrors'
+import { kebabToCamelCase, keysOf } from '../utils/object'
+import { CamelCase } from '../utils/TypeUtils'
+import {
+	getMissingParamMessage,
+	getValidationResultMessage as getValidationFailedMessage,
+} from '../utils/validationMessages'
+import { Validator } from '../validators/types'
+
+type CheckIfOptional<T, B extends boolean | undefined> = B extends false ? T : T | undefined
+
+type HeaderToCamelCase<T> = T extends string ? CamelCase<Uncapitalize<T>> : T
+
+type ValidatedData<T extends Record<string, Validator<any>>> = {
+	[K in keyof T as HeaderToCamelCase<K>]: CheckIfOptional<ReturnType<T[K]['parse']>, T[K]['optional']>
+}
+
+export const useHeaderParams = <ValidatorsT extends Record<string, Validator<any>>>(
+	ctx: ParameterizedContext,
+	validators: ValidatorsT
+) => {
+	const headers = ctx.headers
+	const params = keysOf(validators).map((name) => ({
+		name: name.toLowerCase(),
+		originalName: name,
+		validator: validators[name],
+	}))
+
+	const missingParams = params.filter((param) => !headers[param.name] && !param.validator.optional)
+
+	if (missingParams.length > 0) {
+		throw new ValidationError(
+			`Missing headers: ${missingParams.map((param) => getMissingParamMessage(param)).join(', ')}`
+		)
+	}
+
+	const validationResults = params.map((param) => {
+		const paramValue = headers[param.name]
+
+		// 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 as string)
+			const parsedValue = validatorObject.parse(paramValue as string)
+			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 header validation: ${failedValidations
+				.map((result) => getValidationFailedMessage(result.param))
+				.join(', ')}`
+		)
+	}
+
+	const successfulValidations = validationResults.filter((result) => result.validated)
+
+	const returnValue: Record<string, unknown> = {}
+	successfulValidations.forEach((result) => {
+		returnValue[kebabToCamelCase(result.param.originalName)] = result.parsedValue
+	})
+
+	return returnValue as ValidatedData<ValidatorsT>
+}
+
+export const useRequestHeaders = useHeaderParams