moonflower 1.2.0 → 1.3.1

package/src/openapi/manager/OpenApiManager.ts

@@ -45,6 +45,7 @@ export class OpenApiManager {
 
 	private isInitialized = false
 	private registeredRouters: Router[] = []
+	private prebuiltSpec: Record<string, unknown> | null = null
 
 	constructor(
 		private apiDocsHeader: ApiDocsHeader,
@@ -125,9 +126,24 @@ export class OpenApiManager {
 		return this
 	}
 
+	public getPrebuiltSpec(): Record<string, unknown> | null {
+		return this.prebuiltSpec
+	}
+
+	public setPrebuiltSpec(spec: Record<string, unknown>) {
+		this.prebuiltSpec = spec
+		return this
+	}
+
+	public clearPrebuiltSpec() {
+		this.prebuiltSpec = null
+		return this
+	}
+
 	public reset() {
 		this.exposedModels = []
 		this.endpoints = []
+		this.prebuiltSpec = null
 	}
 
 	public static getInstance() {

package/src/openapi/router/OpenApiRouter.ts

@@ -5,7 +5,12 @@ import { OpenApiManager } from '../manager/OpenApiManager'
 const router = new Router({ skipOpenApiAnalysis: true })
 
 router.get('/api-json', () => {
-	return generateOpenApiSpec(OpenApiManager.getInstance())
+	const manager = OpenApiManager.getInstance()
+	const prebuilt = manager.getPrebuiltSpec()
+	if (prebuilt) {
+		return prebuilt
+	}
+	return generateOpenApiSpec(manager)
 })
 
 export const OpenApiRouter = router

package/src/test/app.spec.ts

@@ -1,7 +1,13 @@
+import * as fs from 'fs'
+import Koa from 'koa'
+import * as os from 'os'
+import * as path from 'path'
 import request from 'supertest'
 import { vi } from 'vitest'
 
 import { generateOpenApiSpec } from '../openapi/generatorModule/generatorModule'
+import { initOpenApiEngine } from '../openapi/initOpenApiEngine'
+import { OpenApiManager } from '../openapi/manager/OpenApiManager'
 import { app } from './app'
 
 describe('TestAppRouter', () => {
@@ -148,4 +154,25 @@ describe('OpenApiRouter', () => {
 			},
 		})
 	})
+
+	it('serves a prebuilt spec from file', async () => {
+		const manager = OpenApiManager.getInstance()
+		const liveSpec = generateOpenApiSpec(manager)
+
+		const specPath = path.join(os.tmpdir(), `moonflower-test-spec-${Date.now()}.json`)
+		fs.writeFileSync(specPath, JSON.stringify(liveSpec))
+
+		try {
+			const prebuiltApp = new Koa()
+			prebuiltApp.use(initOpenApiEngine({ specPath }))
+
+			const response = await request(prebuiltApp.callback()).get('/api-json')
+			expect(response.status).toBe(200)
+			const responseJson = JSON.parse(response.text)
+			expect(responseJson).toEqual(liveSpec)
+		} finally {
+			manager.clearPrebuiltSpec()
+			fs.unlinkSync(specPath)
+		}
+	})
 })

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'
+}

package/vite.config.ts

@@ -23,6 +23,7 @@ const entries = {
 	'router/Router': resolve(__dirname, 'src/router/Router.ts'),
 	'validators/BuiltInValidators': resolve(__dirname, 'src/validators/BuiltInValidators.ts'),
 	'validators/ParamWrappers': resolve(__dirname, 'src/validators/ParamWrappers.ts'),
+	'cli/cli': resolve(__dirname, 'src/cli/cli.ts'),
 }
 
 export const baseViteConfig: ViteUserConfig = {
@@ -53,6 +54,8 @@ export const baseViteConfig: ViteUserConfig = {
 				'@ts-morph/common',
 				'typescript',
 				'ts-morph',
+				'yargs',
+				'yargs/helpers',
 			],
 			output: {
 				globals: {