moonflower 0.9.0

package/src/utils/loadTestData.ts

@@ -0,0 +1,15 @@
+import * as path from 'path'
+import { Project } from 'ts-morph'
+
+export const loadTestData = (filePath: string) => {
+	const project = new Project({
+		tsConfigFilePath: path.resolve('./tsconfig.json'),
+	})
+
+	const sourceFile = project.getSourceFile(filePath)
+	if (!sourceFile) {
+		throw new Error('Test data file not found')
+	}
+
+	return sourceFile
+}

package/src/utils/mockContext.ts

@@ -0,0 +1,86 @@
+import Koa from 'koa'
+import * as httpMocks from 'node-mocks-http'
+
+import { keysOf } from './object'
+import { ExtractedRequestParams } from './TypeUtils'
+
+export interface MockContext<RequestBody = undefined> extends Koa.Context {
+	request: Koa.Context['request'] & {
+		body?: RequestBody
+	}
+}
+
+export const mockContext = <State = Koa.DefaultState, Context = MockContext>() => {
+	const app = new Koa<State, Context>()
+	const req = httpMocks.createRequest()
+	const res = httpMocks.createResponse()
+	const context = app.createContext(req, res) as Koa.ParameterizedContext<State, Context>
+	res.statusCode = 404
+	return context
+}
+
+export const mockContextPath = <Context extends Koa.ParameterizedContext, Path extends string>(
+	ctx: Context,
+	path: Path,
+	params: Record<string, string>
+) => {
+	const typedContext = ctx as Context & { params: any } & ExtractedRequestParams<Path>
+	ctx.request.path = path
+	typedContext.params = params
+	return typedContext
+}
+
+export const mockContextQuery = <Context extends Koa.ParameterizedContext>(
+	ctx: Context,
+	params: Record<string, string>
+) => {
+	ctx.query = params
+	return ctx
+}
+
+export const mockContextCookies = <Context extends Koa.ParameterizedContext>(
+	ctx: Context,
+	params: Record<string, string | { value: string; expires?: Date }>
+) => {
+	const cookies = keysOf(params).map((name) => {
+		const cookieData = params[name]
+
+		return {
+			name,
+			value: typeof cookieData === 'string' ? cookieData : cookieData.value,
+			expires: typeof cookieData === 'string' ? undefined : cookieData.expires,
+		}
+	})
+	ctx.cookies = {
+		...ctx.cookies,
+		get: (name: string) => {
+			return cookies.find((cookie) => cookie.name === name)?.value || undefined
+		},
+	}
+	return ctx
+}
+
+export const mockContextHeaders = <Context extends Koa.ParameterizedContext>(
+	ctx: Context,
+	params: Record<string, string>
+) => {
+	ctx.request.headers = params
+	return ctx
+}
+
+export const mockContextBody = <Context extends Koa.ParameterizedContext>(
+	ctx: Context,
+	params: Record<string, string | number | boolean | object | null>
+) => {
+	ctx.request.body = params
+	ctx.request.rawBody = JSON.stringify(params)
+	return ctx
+}
+
+export const mockContextRawBody = <Context extends Koa.ParameterizedContext>(
+	ctx: Context,
+	params: string
+) => {
+	ctx.request.rawBody = params
+	return ctx
+}

package/src/utils/nameOf.ts

@@ -0,0 +1,7 @@
+export interface ClassConstructor {
+	new (): unknown
+}
+
+export const nameOf = <T extends ClassConstructor | (() => unknown)>(a: T) => {
+	return a.name
+}

package/src/utils/object.spec.ts

@@ -0,0 +1,27 @@
+import { camelToKebabCase, camelToSnakeCase, snakeToCamelCase, uncapitalize } from './object'
+
+describe('object utilities', () => {
+	describe('uncapitalize', () => {
+		it('uncapitalizes string correctly', () => {
+			expect(uncapitalize('CapitalizedString')).toEqual('capitalizedString')
+		})
+	})
+
+	describe('snakeToCamelCase', () => {
+		it('transforms snake_case string correctly', () => {
+			expect(snakeToCamelCase('snake_case_string')).toEqual('snakeCaseString')
+		})
+	})
+
+	describe('camelToSnakeCase', () => {
+		it('transforms camelCase string correctly', () => {
+			expect(camelToSnakeCase('camelCaseString')).toEqual('camel_case_string')
+		})
+	})
+
+	describe('camelToKebabCase', () => {
+		it('transforms camelCase string correctly', () => {
+			expect(camelToKebabCase('camelCaseString')).toEqual('camel-case-string')
+		})
+	})
+})

package/src/utils/object.ts

@@ -0,0 +1,17 @@
+export const keysOf = <T extends string | number | symbol>(object: Record<T, unknown>) => {
+	return Object.keys(object) as (keyof typeof object)[]
+}
+
+export const uncapitalize = (value: string) => `${value.substring(0, 1).toLowerCase()}${value.substring(1)}`
+
+export const snakeToCamelCase = (value: string) => {
+	return value.replace(/(?!^)_(.)/g, (_, char) => char.toUpperCase())
+}
+
+export const kebabToCamelCase = (value: string) => {
+	return value.replace(/(?!^)-(.)/g, (_, char) => char.toUpperCase())
+}
+
+export const camelToSnakeCase = (value: string) => value.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`)
+
+export const camelToKebabCase = (value: string) => value.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)

package/src/utils/printers.spec.ts

@@ -0,0 +1,103 @@
+import { Project } from 'ts-morph'
+import * as util from 'util'
+import { vi } from 'vitest'
+
+import { debugNode, debugNodeChildren, debugNodes, debugObject } from './printers'
+
+describe('printer utilities', () => {
+	const consoleMock = vi.fn()
+
+	beforeEach(() => {
+		consoleMock.mockClear()
+		console.debug = consoleMock
+	})
+
+	describe('debugNode', () => {
+		it('handles undefined node', () => {
+			debugNode(undefined)
+			expect(consoleMock).toHaveBeenCalledWith('Node is undefined')
+		})
+
+		it('handles simple node', () => {
+			const project = new Project({
+				useInMemoryFileSystem: true,
+			})
+			const sourceFile = project.createSourceFile(
+				'/test-file',
+				`
+				type Foo = string
+				`
+			)
+
+			debugNode(sourceFile.getFirstChild())
+			expect(consoleMock).toHaveBeenCalledWith([{ kind: 'TypeAliasDeclaration', text: 'type Foo = string' }])
+		})
+	})
+
+	describe('debugNodes', () => {
+		it('handles undefined node', () => {
+			debugNodes(undefined)
+			expect(consoleMock).toHaveBeenCalledWith('Nodes are undefined')
+		})
+
+		it('handles simple node', () => {
+			const project = new Project({
+				useInMemoryFileSystem: true,
+			})
+			const sourceFile = project.createSourceFile(
+				'/test-file',
+				`
+				type Foo = string
+				`
+			)
+
+			debugNodes(sourceFile.getChildren())
+			expect(consoleMock).toHaveBeenCalledWith([{ kind: 'TypeAliasDeclaration', text: 'type Foo = string' }])
+		})
+	})
+
+	describe('debugNodeChildren', () => {
+		it('handles undefined node', () => {
+			debugNodeChildren(undefined)
+			expect(consoleMock).toHaveBeenCalledWith('Node is undefined')
+		})
+
+		it('handles simple node', () => {
+			const project = new Project({
+				useInMemoryFileSystem: true,
+			})
+			const sourceFile = project.createSourceFile(
+				'/test-file',
+				`
+				type Foo = string
+				`
+			)
+
+			debugNodeChildren(sourceFile.getFirstChild())
+			expect(consoleMock).toHaveBeenCalledWith([{ kind: 'TypeAliasDeclaration', text: 'type Foo = string' }])
+		})
+	})
+
+	describe('debugObject', () => {
+		it('prints non-object correctly', () => {
+			debugObject('test')
+			expect(consoleMock).toHaveBeenCalledWith('test')
+		})
+
+		it('prints object correctly', () => {
+			debugObject({
+				q1: 'qqq',
+				q2: 'www',
+			})
+			expect(consoleMock).toHaveBeenCalledWith(
+				util.inspect(
+					{
+						q1: 'qqq',
+						q2: 'www',
+					},
+					{ showHidden: false, depth: null, colors: true }
+				)
+			)
+		})
+	})
+})

package/src/utils/printers.ts

@@ -0,0 +1,49 @@
+import { Node } from 'ts-morph'
+import * as util from 'util'
+
+export const debugNode = (node: Node | undefined) => {
+	console.debug('Node:')
+	if (!node) {
+		console.debug('Node is undefined')
+		return
+	}
+	console.debug({
+		kind: node.getKindName(),
+		text: node.getText(),
+	})
+	debugNodeChildren(node)
+}
+
+export const debugNodes = (nodes: Node | Node[] | undefined) => {
+	console.debug('Nodes:')
+	if (!nodes) {
+		console.debug('Nodes are undefined')
+		return
+	}
+	if (Array.isArray(nodes)) {
+		nodes.forEach((node) => debugNode(node))
+	} else {
+		debugNode(nodes)
+	}
+}
+
+export const debugNodeChildren = (node: Node | undefined) => {
+	console.debug('Children:')
+	if (!node) {
+		console.debug('Node is undefined')
+		return
+	}
+	const values = node.getChildren().map((child) => ({
+		kind: child.getKindName(),
+		text: child.getText(),
+	}))
+	console.debug(values)
+}
+
+export const debugObject = (object: Record<any, any> | any) => {
+	if (typeof object === 'object') {
+		console.debug(util.inspect(object, { showHidden: false, depth: null, colors: true }))
+	} else {
+		console.debug(object)
+	}
+}

package/src/utils/validationMessages.ts

@@ -0,0 +1,65 @@
+import { Validator } from '../validators/types'
+
+export const getMissingParamMessage = (
+	result:
+		| {
+				name: string
+				validator: Pick<Validator<unknown>, 'description' | 'errorMessage'>
+		  }
+		| {
+				originalName: string
+				validator: Pick<Validator<unknown>, 'description' | 'errorMessage'>
+		  }
+) => {
+	const name = 'name' in result ? result.name : result.originalName
+	const { description } = result.validator
+
+	if (description) {
+		return `'${name}' (${description})`
+	}
+	return `'${name}'`
+}
+
+export const getValidationResultMessage = (
+	result:
+		| {
+				name: string
+				validator: Pick<Validator<unknown>, 'description' | 'errorMessage'>
+		  }
+		| {
+				originalName: string
+				validator: Pick<Validator<unknown>, 'description' | 'errorMessage'>
+		  }
+) => {
+	const name = 'name' in result ? result.name : result.originalName
+	const { description, errorMessage } = result.validator
+
+	if (errorMessage) {
+		return `'${name}' (${errorMessage})`
+	}
+	if (description) {
+		return `'${name}' (${description})`
+	}
+	return `'${name}'`
+}
+
+export const getMissingRawBodyMessage = (validator: Validator<unknown>) => {
+	const { description } = validator
+
+	if (description) {
+		return `Missing request body (${description}).`
+	}
+	return 'Missing request body.'
+}
+
+export const getFailedRawBodyValidationMessage = (validator: Validator<unknown>) => {
+	const { description, errorMessage } = validator
+
+	if (errorMessage) {
+		return `Failed request body validation (${errorMessage}).`
+	}
+	if (description) {
+		return `Failed request body validation (${description}).`
+	}
+	return 'Failed request body validation.'
+}

package/src/validators/BuiltInValidators.ts

@@ -0,0 +1,64 @@
+import { ValidationError } from '../errors/UserFacingErrors'
+import { BuiltInValidatorParam } from './InternalParamWrappers'
+
+export const EmailValidator = BuiltInValidatorParam({
+	parse: (v) => String(v),
+	validate: (v) => v.includes('@'),
+	description: "A string containing an '@' sign",
+	errorMessage: "Must include an '@' sign",
+})
+export const BooleanValidator = BuiltInValidatorParam({
+	prevalidate: (v) => v === '0' || v === '1' || v === 'false' || v === 'true',
+	parse: (v) => v === '1' || v === 'true',
+	description: 'Any boolean value',
+	errorMessage: "Must be '0', '1', 'false' or 'true'",
+})
+export const NullableBooleanValidator = BuiltInValidatorParam({
+	prevalidate: (v) => v === '0' || v === '1' || v === 'false' || v === 'true' || v === null,
+	parse: (v) => v === '1' || v === 'true' || v === null,
+	description: 'Any boolean value',
+	errorMessage: "Must be '0', '1', 'false' or 'true'",
+})
+export const StringValidator = BuiltInValidatorParam({
+	parse: (v) => String(v),
+	description: 'Any string value',
+	errorMessage: 'Must be a valid string',
+})
+export const NullableStringValidator = BuiltInValidatorParam({
+	parse: (v) => v,
+	description: 'Any string or null value',
+	errorMessage: 'Must be a valid string or null',
+})
+export const NonEmptyStringValidator = BuiltInValidatorParam({
+	parse: (v) => String(v),
+	validate: (v) => v.length > 0,
+	description: 'Any string value with at least one character',
+	errorMessage: 'Must be a string with at least one character',
+})
+export const NumberValidator = BuiltInValidatorParam({
+	parse: (v) => Number(v),
+	validate: (v) => Number.isFinite(v) && !Number.isNaN(v),
+	description: 'Any numeric value',
+	errorMessage: 'Must be a valid number',
+})
+export const NullableNumberValidator = BuiltInValidatorParam({
+	parse: (v) => (v === null ? null : Number(v)),
+	validate: (v) => v === null || (Number.isFinite(v) && !Number.isNaN(v)),
+	description: 'Any numeric value',
+	errorMessage: 'Must be a valid number',
+})
+export const BigIntValidator = BuiltInValidatorParam({
+	parse: (v) => {
+		if (v === null) {
+			throw new ValidationError('Encountered an unexpected null value')
+		}
+		return BigInt(v)
+	},
+	description: 'Any numeric value',
+	errorMessage: 'Must be a valid number',
+})
+export const NullableBigIntValidator = BuiltInValidatorParam({
+	parse: (v) => (v === null ? null : BigInt(v)),
+	description: 'Any numeric value',
+	errorMessage: 'Must be a valid number',
+})

package/src/validators/InternalParamWrappers.ts

@@ -0,0 +1,14 @@
+import { BuiltInValidator } from './types'
+
+/**
+ * More complex type to preserve description and errorMessage in .d.ts file.
+ * Functionally identical to RequiredParam.
+ * For internal use only.
+ */
+export const BuiltInValidatorParam = <T, DescriptionT extends string, ErrorMessageT extends string>(
+	validator: Omit<BuiltInValidator<T, DescriptionT, ErrorMessageT>, 'optional'> &
+		Pick<BuiltInValidator<T, DescriptionT, ErrorMessageT>, 'description' | 'errorMessage'>
+): BuiltInValidator<T, DescriptionT, ErrorMessageT> & { optional: false } => ({
+	...validator,
+	optional: false,
+})

package/src/validators/ParamWrappers.ts

@@ -0,0 +1,22 @@
+import { Validator } from './types'
+
+export const PathParam = <T>(
+	validator: Omit<Validator<T>, 'optional'>
+): Validator<T> & { optional: false } => ({
+	...validator,
+	optional: false,
+})
+
+export const RequiredParam = <T>(
+	validator: Omit<Validator<T>, 'optional'>
+): Validator<T> & { optional: false } => ({
+	...validator,
+	optional: false,
+})
+
+export const OptionalParam = <T>(
+	validator: Omit<Validator<T>, 'optional'>
+): Validator<T> & { optional: true } => ({
+	...validator,
+	optional: true,
+})

package/src/validators/types.ts

@@ -0,0 +1,35 @@
+type DeepPartial<T> = {
+	[P in keyof T]?: T[P] extends Array<infer U>
+		? Array<DeepPartial<U>>
+		: T[P] extends ReadonlyArray<infer U>
+		? ReadonlyArray<DeepPartial<U>>
+		: DeepPartial<T[P]>
+}
+
+export type ValidateArg<T> = T extends object ? DeepPartial<T> : T
+
+export type Validator<T> = {
+	prevalidate?: (v: string | null) => boolean
+	parse: (v: string | null) => T
+	validate?: (v: ValidateArg<T>) => boolean
+	/**
+	 * The field is optional and validation will be skipped if it is not provided.
+	 * Optional parameters will always be nullable.
+	 * For `usePathParams` this field is ignored.
+	 */
+	optional: boolean
+	/**
+	 * OpenAPI description field.
+	 * If 'errorMessage' is not provided, will be used to inform user in the event of failed validation.
+	 */
+	description?: string
+	/**
+	 * Error message sent to user when validation fails.
+	 */
+	errorMessage?: string
+}
+
+export type BuiltInValidator<T, DescriptionT extends string, ErrorMessageT extends string> = Validator<T> & {
+	description: DescriptionT
+	errorMessage: ErrorMessageT
+}

package/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"sourceMap": false,
+		"declaration": true,
+	},
+	"exclude": [
+		"node_modules",
+		"test",
+		"dist",
+		"**/*spec.ts",
+		".eslintrc.js",
+		"vite.config.ts"
+	]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"declaration": true,
+		"declarationMap": true,
+		"removeComments": true,
+		"strict": true,
+		"emitDecoratorMetadata": true,
+		"experimentalDecorators": true,
+		"allowSyntheticDefaultImports": true,
+		"target": "es2017",
+		"esModuleInterop": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+		"incremental": true,
+		"skipLibCheck": true,
+		"strictNullChecks": true,
+		"noImplicitAny": true,
+		"strictBindCallApply": true,
+		"forceConsistentCasingInFileNames": true,
+		"noFallthroughCasesInSwitch": true
+	},
+	"include": [
+		"cli/**/*",
+		"src/**/*",
+		".eslintrc.js",
+		"vite.config.ts",
+	]
+}

package/vite.config.ts

@@ -0,0 +1,16 @@
+import { resolve } from 'path'
+import { defineConfig, UserConfig } from 'vitest/config'
+
+export const baseViteConfig: UserConfig = {
+	test: {
+		globals: true,
+		setupFiles: 'src/setupTests.ts',
+	},
+	resolve: {
+		alias: {
+			'@src': resolve(__dirname, './src'),
+		},
+	},
+}
+
+export default defineConfig(baseViteConfig)