moonflower 0.9.0

package/src/openapi/analyzerModule/types.ts

@@ -0,0 +1,72 @@
+export type ShapeOfType =
+	| ShapeOfProperty
+	| ShapeOfStringLiteral
+	| ShapeOfNumberLiteral
+	| ShapeOfUnion
+	| ShapeOfUnionEntry
+	| ShapeOfRecord
+	| ShapeOfArray
+	| ShapeOfRef
+	| ShapeOfTuple
+	| ShapeOfTupleEntry
+
+export type ShapeOfProperty = {
+	role: 'property'
+	identifier: string
+	shape: string | ShapeOfType[]
+	optional: boolean
+}
+
+export type ShapeOfStringLiteral = {
+	role: 'literal_string'
+	shape: string
+	optional: boolean
+}
+
+export type ShapeOfNumberLiteral = {
+	role: 'literal_number'
+	shape: string
+	optional: boolean
+}
+
+export type ShapeOfUnion = {
+	role: 'union'
+	shape: ShapeOfUnionEntry[]
+	optional: boolean
+}
+
+export type ShapeOfUnionEntry = {
+	role: 'union_entry'
+	shape: string | ShapeOfType[]
+	optional: boolean
+}
+
+export type ShapeOfRecord = {
+	role: 'record'
+	shape: string | ShapeOfType[]
+	optional: boolean
+}
+
+export type ShapeOfArray = {
+	role: 'array'
+	shape: string | ShapeOfType[]
+	optional: boolean
+}
+
+export type ShapeOfRef = {
+	role: 'ref'
+	shape: string
+	optional: boolean
+}
+
+export type ShapeOfTuple = {
+	role: 'tuple'
+	shape: ShapeOfTupleEntry[]
+	optional: boolean
+}
+
+export type ShapeOfTupleEntry = {
+	role: 'tuple_entry'
+	shape: string | ShapeOfType[]
+	optional: boolean
+}

package/src/openapi/discoveryModule/discoverImports/discoverImports.ts

@@ -0,0 +1,43 @@
+import { SourceFile, SyntaxKind } from 'ts-morph'
+
+type Props = {
+	sourceFile: SourceFile
+	originalName: string
+}
+
+export const discoverImportedName = ({ sourceFile, originalName }: Props): string | null => {
+	const importDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.ImportDeclaration)
+	const discoveredName = importDeclarations
+		.filter((declaration) => {
+			// declaration
+			const importPathNode = declaration.getLastChildByKind(SyntaxKind.StringLiteral)
+			if (!importPathNode) {
+				return false
+			}
+
+			const importPath = importPathNode.getText()
+
+			return (
+				/moonflower/.test(importPath) ||
+				process.env.NODE_ENV === 'test' ||
+				process.env.NODE_ENV === 'development'
+			)
+		})
+		.map((declaration) => {
+			const routerImport = declaration
+				.getDescendantsOfKind(SyntaxKind.ImportSpecifier)
+				.filter((i) => i.getFirstChildByKind(SyntaxKind.Identifier)?.getText() === originalName)[0]
+
+			if (!routerImport) {
+				return null
+			}
+
+			return routerImport.getLastChildByKindOrThrow(SyntaxKind.Identifier).getText()
+		})
+		.filter((declaration): declaration is NonNullable<typeof declaration> => declaration !== null)[0]
+
+	if (!discoveredName) {
+		return null
+	}
+	return discoveredName
+}

package/src/openapi/discoveryModule/discoverRouterFiles/data/testRouterA.spec.data.ts

@@ -0,0 +1,7 @@
+import { Router } from '../../../../router/Router'
+
+export const router = new Router()
+
+router.get('/api-a', () => {
+	return 'test-data'
+})

package/src/openapi/discoveryModule/discoverRouterFiles/data/testRouterB.spec.data.ts

@@ -0,0 +1,7 @@
+import { Router } from '../../../../router/Router'
+
+export const router = new Router()
+
+router.get('/api-b', () => {
+	return 'test-data'
+})

package/src/openapi/discoveryModule/discoverRouterFiles/discoverRouterFiles.spec.ts

@@ -0,0 +1,36 @@
+import { resolve } from 'path'
+
+import { discoverRouterFiles } from './discoverRouterFiles'
+
+describe('discoverRouterFiles', () => {
+	it('discovers routers from folder correctly', () => {
+		const { discoveredRouterFiles } = discoverRouterFiles({
+			targetPath: resolve(__dirname, '.'),
+			tsConfigPath: resolve('./tsconfig.json'),
+		})
+
+		expect(discoveredRouterFiles.length).toEqual(2)
+	})
+
+	it('respects ignoring files by string', () => {
+		const { discoveredRouterFiles } = discoverRouterFiles({
+			targetPath: resolve(__dirname, '.'),
+			tsConfigPath: resolve('./tsconfig.json'),
+			excludedFiles: ['testRouterA'],
+		})
+
+		expect(discoveredRouterFiles.length).toEqual(1)
+		expect(discoveredRouterFiles[0].fileName.endsWith('testRouterB.spec.data.ts')).toBeTruthy()
+	})
+
+	it('respects ignoring files by regex', () => {
+		const { discoveredRouterFiles } = discoverRouterFiles({
+			targetPath: resolve(__dirname, '.'),
+			tsConfigPath: resolve('./tsconfig.json'),
+			excludedFiles: [/B/g],
+		})
+
+		expect(discoveredRouterFiles.length).toEqual(1)
+		expect(discoveredRouterFiles[0].fileName.endsWith('testRouterA.spec.data.ts')).toBeTruthy()
+	})
+})

package/src/openapi/discoveryModule/discoverRouterFiles/discoverRouterFiles.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { Project } from 'ts-morph'
+
+import { discoverRouters } from '../discoverRouters/discoverRouters'
+
+export type DiscoveredSourceFile = ReturnType<typeof discoverRouterFiles>['discoveredRouterFiles'][number]
+
+export const discoverRouterFiles = ({
+	targetPath,
+	tsConfigPath,
+	excludedFiles,
+}: {
+	targetPath: string
+	tsConfigPath: string
+	excludedFiles?: (string | RegExp)[]
+}) => {
+	if (!fs.existsSync(targetPath)) {
+		return { discoveredRouterFiles: [], discoveredSourceFiles: [] }
+	}
+
+	const usersExcludedFiles = (excludedFiles ?? []).map((value) =>
+		typeof value === 'string' ? new RegExp(`${value}`) : value
+	)
+	const excludedPrefixes = [/^node_modules/, /^\./, /^dist/].concat(usersExcludedFiles ?? [])
+
+	const files = fs.readdirSync(targetPath, { recursive: true }).filter((filePath): filePath is string => {
+		if (typeof filePath !== 'string') {
+			return false
+		}
+
+		if (excludedPrefixes.some((p) => p.test(filePath))) {
+			return false
+		}
+
+		if (!filePath.endsWith('.ts')) {
+			return false
+		}
+		return true
+	})
+
+	const project = new Project({
+		tsConfigFilePath: tsConfigPath,
+	})
+
+	const allSourceFiles = files
+		.map((fileName) => {
+			const filePath = path.resolve(targetPath, fileName)
+			return {
+				fileName,
+				sourceFile: project.getSourceFile(filePath),
+			}
+		})
+		.filter(
+			(
+				file
+			): file is Omit<typeof file, 'sourceFile'> & { sourceFile: NonNullable<typeof file['sourceFile']> } =>
+				!!file.sourceFile
+		)
+
+	const routersInFiles = allSourceFiles
+		.map((file) => {
+			const { fileName, sourceFile } = file
+			const routers = discoverRouters(sourceFile)
+			if (routers.named.length === 0 && routers.anonymous.length === 0) {
+				return null
+			}
+			return {
+				fileName,
+				sourceFile,
+				routers,
+			}
+		})
+		.filter((file): file is NonNullable<typeof file> => file !== null)
+
+	return {
+		discoveredRouterFiles: routersInFiles,
+		discoveredSourceFiles: allSourceFiles.map((file) => file.sourceFile),
+	}
+}

package/src/openapi/discoveryModule/discoverRouters/discoverRouters.spec.data.ts

@@ -0,0 +1,42 @@
+import { Router as RenamedRouter } from '../../../router/Router'
+
+const namedRouterVariable = new RenamedRouter()
+
+namedRouterVariable.get('/api', () => {
+	return 'test-data'
+})
+
+const anotherRouterVariable = new RenamedRouter()
+	.use((_, next) => next())
+	.with(() => {
+		const user = { id: '123' }
+		return {
+			user,
+		}
+	})
+
+anotherRouterVariable.get('/api', () => {
+	return 'more-test-data'
+})
+
+export default new RenamedRouter()
+	.get('/anonapi', () => {
+		return 'otherdata'
+	})
+	.get('/anonapitwo', () => {
+		return 'otherdata'
+	})
+	.get('/anonapithree', () => {
+		return 'otherdata'
+	})
+
+// Exists to make sure that discovery module ignores unrelated objects
+class Router {
+	value = 'foo'
+
+	setValue(val: string) {
+		this.value = val
+	}
+}
+const unrelatedObject = new Router()
+unrelatedObject.setValue('bar')

package/src/openapi/discoveryModule/discoverRouters/discoverRouters.spec.ts

@@ -0,0 +1,18 @@
+import { SyntaxKind } from 'ts-morph'
+
+import { loadTestData } from '../../../utils/loadTestData'
+import { discoverRouters } from './discoverRouters'
+
+describe('discoverRouters', () => {
+	const dataFile = loadTestData('discoverRouters.spec.data.ts')
+
+	it('discovers routers from single file correctly', () => {
+		const routers = discoverRouters(dataFile)
+
+		expect(routers.named.length).toEqual(2)
+		expect(routers.named[0]).toEqual('namedRouterVariable')
+		expect(routers.named[1]).toEqual('anotherRouterVariable')
+		expect(routers.anonymous.length).toEqual(1)
+		expect(routers.anonymous[0].getKind()).toEqual(SyntaxKind.CallExpression)
+	})
+})

package/src/openapi/discoveryModule/discoverRouters/discoverRouters.ts

@@ -0,0 +1,39 @@
+import { SourceFile, SyntaxKind } from 'ts-morph'
+
+import { Router } from '../../../router/Router'
+import { nameOf } from '../../../utils/nameOf'
+import { discoverImportedName } from '../discoverImports/discoverImports'
+
+export const discoverRouters = (sourceFile: SourceFile) => {
+	const routerClassName = discoverImportedName({
+		sourceFile,
+		originalName: nameOf(Router),
+	})
+
+	if (!routerClassName) {
+		return { named: [], anonymous: [] }
+	}
+
+	const routers = sourceFile
+		.getDescendantsOfKind(SyntaxKind.NewExpression)
+		.filter((exp) => exp.getFirstChildByKindOrThrow(SyntaxKind.Identifier).getText() === routerClassName)
+
+	const namedRouters = routers.filter((node) => !!node.getFirstAncestorByKind(SyntaxKind.VariableDeclaration))
+	const anonymousRouters = routers.filter(
+		(node) => !!node.getFirstAncestorByKind(SyntaxKind.ExportAssignment)
+	)
+
+	return {
+		named: namedRouters.map((node) =>
+			node
+				.getFirstAncestorByKindOrThrow(SyntaxKind.VariableDeclaration)
+				.getFirstChildByKindOrThrow(SyntaxKind.Identifier)
+				.getText()
+		),
+		anonymous: anonymousRouters.map((node) =>
+			node
+				.getFirstAncestorByKindOrThrow(SyntaxKind.ExportAssignment)
+				.getFirstChildByKindOrThrow(SyntaxKind.CallExpression)
+		),
+	}
+}

package/src/openapi/discoveryModule/index.ts

@@ -0,0 +1,2 @@
+export * from './discoverRouterFiles/discoverRouterFiles'
+export * from './discoverRouters/discoverRouters'

package/src/openapi/generatorModule/generateComponentSchemas.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { ExposedModelData } from '../types'
+import { getSchema, SchemaType } from './getSchema'
+
+export const generateComponentSchemas = (models: ExposedModelData[]) => {
+	const schemas: Record<string, SchemaType> = {}
+
+	models.forEach((model) => {
+		schemas[model.name] = getSchema(model.shape)
+	})
+	return schemas
+}

package/src/openapi/generatorModule/generatePaths.ts

@@ -0,0 +1,138 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { ApiDocsPreferences } from '../manager/OpenApiManager'
+import { EndpointData, PathDefinition } from '../types'
+import { getSchema } from './getSchema'
+
+export const generatePaths = (endpoints: EndpointData[], preferences: ApiDocsPreferences) => {
+	const paths: Record<
+		string,
+		{
+			get?: PathDefinition
+			post?: PathDefinition
+			put?: PathDefinition
+			patch?: PathDefinition
+			delete?: PathDefinition
+		}
+	> = {}
+
+	const { allowOptionalPathParams } = preferences
+
+	endpoints.forEach((endpoint) => {
+		const path = endpoint.path
+			.split('/')
+			.map((param) => {
+				if (param.startsWith(':')) {
+					return `{${param.substring(1).replace('?', '')}}`
+				}
+				return param
+			})
+			.join('/')
+
+		const pathParams = endpoint.requestPathParams.map((param) => ({
+			name: param.identifier,
+			in: 'path' as const,
+			description:
+				param.optional && !allowOptionalPathParams
+					? `(Optional parameter) ${param.description}`
+					: param.description ?? '',
+			required: !allowOptionalPathParams || !param.optional,
+			schema: getSchema(param.signature),
+		}))
+
+		const queryParams = endpoint.requestQuery.map((param) => ({
+			name: param.identifier,
+			in: 'query' as const,
+			description: param.description ?? '',
+			required: !param.optional,
+			schema: getSchema(param.signature),
+		}))
+
+		const headerParams = endpoint.requestHeaders.map((param) => ({
+			name: param.identifier,
+			in: 'header' as const,
+			description: param.description ?? '',
+			required: !param.optional,
+			schema: getSchema(param.signature),
+		}))
+
+		const acceptedBodyTypes: Partial<
+			Record<'text/plain' | 'application/json' | 'application/x-www-form-urlencoded', unknown>
+		> = {}
+
+		if (endpoint.rawBody) {
+			acceptedBodyTypes['text/plain'] = {
+				schema: getSchema(endpoint.rawBody.signature),
+			}
+		}
+
+		if (endpoint.objectBody.length > 0) {
+			const properties: Record<string, unknown> = {}
+			endpoint.objectBody.forEach((prop) => {
+				properties[prop.identifier] = getSchema(prop.signature)
+			})
+			const required = endpoint.objectBody.filter((prop) => !prop.optional).map((prop) => prop.identifier)
+			const content = {
+				schema: {
+					type: 'object',
+					properties,
+					required: required.length > 0 ? required : undefined,
+				},
+			}
+			acceptedBodyTypes['application/json'] = content
+			acceptedBodyTypes['application/x-www-form-urlencoded'] = content
+		}
+
+		const requestsWithBody = ['POST', 'PATCH', 'PUT']
+		const requestBody =
+			requestsWithBody.includes(endpoint.method) && Object.keys(acceptedBodyTypes).length > 0
+				? { content: acceptedBodyTypes }
+				: undefined
+
+		const responses: PathDefinition['responses'] = {}
+		endpoint.responses.forEach((response) => {
+			const status = String(response.status)
+
+			const existingSchemas = responses[status]?.['content']?.['application/json']['schema']['oneOf'] ?? []
+
+			const responseSchema = getSchema(response.signature)
+			const content = (() => {
+				if ('type' in responseSchema && (responseSchema.type === 'void' || responseSchema.type === 'null')) {
+					return undefined
+				}
+
+				return {
+					'application/json': {
+						schema: {
+							oneOf: [...existingSchemas, getSchema(response.signature)],
+						},
+					},
+				}
+			})()
+
+			responses[status] = {
+				description: response.description || '',
+				content,
+			}
+		})
+
+		const definition: PathDefinition = {
+			operationId: endpoint.name,
+			summary: endpoint.summary,
+			description: endpoint.description ?? '',
+			parameters: ([] as PathDefinition['parameters'])
+				.concat(pathParams)
+				.concat(queryParams)
+				.concat(headerParams),
+			requestBody: requestBody,
+			responses: responses,
+			tags: endpoint.tags,
+		}
+
+		paths[path] = {
+			...paths[path],
+			[endpoint.method.toLowerCase()]: definition,
+		}
+	})
+
+	return paths
+}

package/src/openapi/generatorModule/generatorModule.ts

@@ -0,0 +1,17 @@
+import { OpenApiManager } from '../manager/OpenApiManager'
+import { generateComponentSchemas } from './generateComponentSchemas'
+import { generatePaths } from './generatePaths'
+
+export const generateOpenApiSpec = (manager: OpenApiManager) => {
+	const header = manager.getHeader()
+	const endpoints = manager.getEndpoints()
+
+	return {
+		openapi: '3.1.0' as const,
+		info: header,
+		paths: generatePaths(endpoints, manager.getPreferences()),
+		components: {
+			schemas: generateComponentSchemas(manager.getExposedModels()),
+		},
+	}
+}

package/src/openapi/generatorModule/getSchema.ts

@@ -0,0 +1,169 @@
+import {
+	ShapeOfNumberLiteral,
+	ShapeOfProperty,
+	ShapeOfRecord,
+	ShapeOfRef,
+	ShapeOfStringLiteral,
+	ShapeOfTuple,
+	ShapeOfType,
+	ShapeOfUnion,
+} from '../../openapi/analyzerModule/types'
+
+export type SchemaType =
+	| { type: string }
+	| { type: string; properties: Record<string, SchemaType>; required: string[] }
+	| { oneOf: SchemaType[] }
+	| { allOf: SchemaType[] }
+	| { type: 'array'; items: SchemaType }
+	| { type: 'array'; items: SchemaType; minItems: number; maxItems: number }
+	| { type: 'object'; additionalProperties: SchemaType }
+	| { type: 'string'; enum: string[] }
+	| { type: 'string'; format: string }
+	| { type: 'number'; enum: string[] }
+	| { $ref: string }
+
+export const getSchema = (shape: string | ShapeOfType[]): SchemaType => {
+	if (typeof shape === 'string' && shape === 'any') {
+		return generateAny()
+	}
+
+	if (typeof shape === 'string' && shape === 'circular') {
+		return generateAny()
+	}
+
+	if (typeof shape === 'string' && shape === 'null') {
+		return {
+			type: 'null',
+		}
+	}
+
+	if (typeof shape === 'string' && shape === 'Date') {
+		return {
+			type: 'string',
+			format: 'date-time',
+		}
+	}
+
+	if (typeof shape === 'string' && shape === 'bigint') {
+		return {
+			type: 'string',
+			format: 'bigint',
+		}
+	}
+
+	if (typeof shape === 'string') {
+		return {
+			type: shape,
+		}
+	}
+
+	if (shape.length === 0) {
+		return {
+			type: 'unknown_20',
+		}
+	}
+
+	const isStringLiteral = shape[0].role === 'literal_string'
+	if (isStringLiteral) {
+		const typedShape = shape[0] as ShapeOfStringLiteral
+		return {
+			type: 'string',
+			enum: [typedShape.shape],
+		}
+	}
+
+	const isNumberLiteral = shape[0].role === 'literal_number'
+	if (isNumberLiteral) {
+		const typedShape = shape[0] as ShapeOfNumberLiteral
+		return {
+			type: 'number',
+			enum: [typedShape.shape],
+		}
+	}
+
+	const isObject = shape[0].role === 'property'
+	if (isObject) {
+		const typedShapes = shape as ShapeOfProperty[]
+		const properties: Record<string, SchemaType> = {}
+		typedShapes.forEach((prop) => {
+			properties[prop.identifier] = getSchema(prop.shape)
+		})
+		const required = typedShapes.filter((prop) => !prop.optional).map((prop) => prop.identifier)
+		return {
+			type: 'object',
+			properties,
+			required: required.length > 0 ? required : undefined,
+		}
+	}
+
+	const isUnion = shape[0].role === 'union'
+	if (isUnion) {
+		const typedShape = shape[0] as ShapeOfUnion
+		return {
+			oneOf: typedShape.shape.map((unionEntry) => getSchema(unionEntry.shape)),
+		}
+	}
+
+	const isRecord = shape[0].role === 'record'
+	if (isRecord) {
+		const recordShape = shape[0] as ShapeOfRecord
+		return {
+			type: 'object',
+			additionalProperties: getSchema(recordShape.shape),
+		}
+	}
+
+	const isArray = shape[0].role === 'array'
+	if (isArray) {
+		return {
+			type: 'array',
+			items: getSchema(shape[0].shape),
+		}
+	}
+
+	const isRef = shape[0].role === 'ref'
+	if (isRef) {
+		const refShape = shape[0] as ShapeOfRef
+		return {
+			$ref: `#/components/schemas/${refShape.shape}`,
+		}
+	}
+
+	const isTuple = shape[0].role === 'tuple'
+	if (isTuple) {
+		const tupleShape = shape[0] as ShapeOfTuple
+		const tupleEntries = tupleShape.shape
+		return {
+			type: 'array',
+			items: {
+				oneOf: tupleEntries.map((entry) => getSchema(entry.shape)),
+			},
+			minItems: tupleEntries.length,
+			maxItems: tupleEntries.length,
+		}
+	}
+
+	return {
+		type: 'unknown_21',
+	}
+}
+
+const generateAny = () => ({
+	oneOf: [
+		{
+			type: 'string',
+		},
+		{
+			type: 'boolean',
+		},
+		{
+			type: 'number',
+		},
+		{
+			type: 'object',
+		},
+		{
+			type: 'array',
+		},
+	],
+})

package/src/openapi/generatorModule/index.ts

@@ -0,0 +1,4 @@
+export * from './generateComponentSchemas'
+export * from './generatePaths'
+export * from './generatorModule'
+export * from './getSchema'