spiceflow 1.0.6 → 1.0.8

package/src/openapi.test.ts

@@ -0,0 +1,294 @@
+import { expect, test } from 'vitest'
+import { Spiceflow } from './spiceflow.js'
+import { openapi } from './openapi.js'
+import { z } from 'zod'
+
+test('openapi response', async () => {
+	const app = await new Spiceflow()
+		.use(
+			openapi({
+				documentation: {
+					info: {
+						title: 'Spiceflow Docs',
+						version: '0.0.0',
+					},
+				},
+			}),
+		)
+		.use(
+			new Spiceflow({ basePath: '/one' }).get(
+				'/ids/:id',
+				({ params }) => {
+					if (Math.random() < 0.5) {
+						// TODO add a way to set status
+
+						return {
+							message: 'sdf',
+						}
+					}
+					return params.id
+				},
+				{
+					response: {
+						200: z.string(),
+						404: z.object({
+							message: z.string(),
+						}),
+					},
+				},
+			),
+		)
+		.patch(
+			'/addBody',
+			async (c) => {
+				let body = await c.request.json()
+				return body
+			},
+			{
+				body: z.object({
+					name: z.string(),
+				}),
+				response: z.object({
+					name: z.string().optional(),
+				}),
+			},
+		)
+		.get(
+			'/queryParams',
+			async (c) => {
+				const query = c.query
+				return query
+			},
+			{
+				query: z.object({
+					name: z.string(),
+				}),
+				response: z.object({
+					name: z.string().optional(),
+				}),
+			},
+		)
+		.post(
+			'/queryParams',
+			async (c) => {
+				const query = c.query
+				return query
+			},
+			{
+				detail: {
+					description: 'This is a post',
+					operationId: 'postQueryParamsXXX',
+				},
+				body: z.object({
+					name: z.string(),
+				}),
+				response: z.object({
+					name: z.string().optional(),
+				}),
+			},
+		)
+		.use(
+			new Spiceflow({ basePath: '/two' }).get(
+				'/ids/:id',
+				({ params }) => params.id,
+				{
+					params: z.object({
+						id: z.string(),
+					}),
+				},
+			),
+		)
+	const openapiSchema = await app
+		.handle(new Request('http://localhost/openapi'))
+		.then((x) => x.json())
+	expect(openapiSchema).toMatchInlineSnapshot(`
+		{
+		  "components": {
+		    "schemas": {},
+		  },
+		  "info": {
+		    "description": "Development documentation",
+		    "title": "Spiceflow Docs",
+		    "version": "0.0.0",
+		  },
+		  "openapi": "3.0.3",
+		  "paths": {
+		    "/addBody": {
+		      "patch": {
+		        "operationId": "patchAddBody",
+		        "parameters": [],
+		        "requestBody": {
+		          "content": {
+		            "application/json": {
+		              "schema": {
+		                "$schema": "http://json-schema.org/draft-07/schema#",
+		                "additionalProperties": false,
+		                "properties": {
+		                  "name": {
+		                    "type": "string",
+		                  },
+		                },
+		                "required": [
+		                  "name",
+		                ],
+		                "type": "object",
+		              },
+		            },
+		          },
+		          "required": true,
+		        },
+		        "responses": {
+		          "200": {
+		            "$schema": "http://json-schema.org/draft-07/schema#",
+		            "content": {
+		              "application/json": {
+		                "schema": {
+		                  "properties": {
+		                    "name": {
+		                      "type": "string",
+		                    },
+		                  },
+		                  "type": "object",
+		                },
+		              },
+		            },
+		          },
+		        },
+		      },
+		    },
+		    "/one/ids/{id}": {
+		      "get": {
+		        "operationId": "getOneIdsById",
+		        "responses": {
+		          "200": {
+		            "$schema": "http://json-schema.org/draft-07/schema#",
+		            "content": {
+		              "application/json": {
+		                "schema": {
+		                  "$schema": "http://json-schema.org/draft-07/schema#",
+		                  "type": "string",
+		                },
+		              },
+		            },
+		          },
+		          "404": {
+		            "$schema": "http://json-schema.org/draft-07/schema#",
+		            "content": {
+		              "application/json": {
+		                "schema": {
+		                  "properties": {
+		                    "message": {
+		                      "type": "string",
+		                    },
+		                  },
+		                  "required": [
+		                    "message",
+		                  ],
+		                  "type": "object",
+		                },
+		              },
+		            },
+		          },
+		        },
+		      },
+		    },
+		    "/openapi": {
+		      "get": {
+		        "operationId": "getOpenapi",
+		        "responses": {},
+		      },
+		    },
+		    "/queryParams": {
+		      "get": {
+		        "operationId": "getQueryParams",
+		        "parameters": [
+		          {
+		            "in": "query",
+		            "name": "name",
+		            "required": true,
+		            "schema": {
+		              "type": "string",
+		            },
+		          },
+		        ],
+		        "responses": {
+		          "200": {
+		            "$schema": "http://json-schema.org/draft-07/schema#",
+		            "content": {
+		              "application/json": {
+		                "schema": {
+		                  "properties": {
+		                    "name": {
+		                      "type": "string",
+		                    },
+		                  },
+		                  "type": "object",
+		                },
+		              },
+		            },
+		          },
+		        },
+		      },
+		      "post": {
+		        "description": "This is a post",
+		        "operationId": "postQueryParamsXXX",
+		        "parameters": [],
+		        "requestBody": {
+		          "content": {
+		            "application/json": {
+		              "schema": {
+		                "$schema": "http://json-schema.org/draft-07/schema#",
+		                "additionalProperties": false,
+		                "properties": {
+		                  "name": {
+		                    "type": "string",
+		                  },
+		                },
+		                "required": [
+		                  "name",
+		                ],
+		                "type": "object",
+		              },
+		            },
+		          },
+		          "required": true,
+		        },
+		        "responses": {
+		          "200": {
+		            "$schema": "http://json-schema.org/draft-07/schema#",
+		            "content": {
+		              "application/json": {
+		                "schema": {
+		                  "properties": {
+		                    "name": {
+		                      "type": "string",
+		                    },
+		                  },
+		                  "type": "object",
+		                },
+		              },
+		            },
+		          },
+		        },
+		      },
+		    },
+		    "/two/ids/{id}": {
+		      "get": {
+		        "operationId": "getTwoIdsById",
+		        "parameters": [
+		          {
+		            "in": "path",
+		            "name": "id",
+		            "required": true,
+		            "schema": {
+		              "type": "string",
+		            },
+		          },
+		        ],
+		        "responses": {},
+		      },
+		    },
+		  },
+		}
+	`)
+})

package/src/openapi.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { JSONSchemaType } from 'ajv'
 import { InternalRoute, isZodSchema, Spiceflow } from './spiceflow.js'
 import { ZodType } from 'zod'
@@ -6,11 +5,8 @@ import { ZodType } from 'zod'
 import type { OpenAPIV3 } from 'openapi-types'
 
 let excludeMethods = ['OPTIONS']
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import type { HTTPMethod, LocalHook, TypeSchema } from './elysia-fork/types.js'
 
-import { Kind, type TSchema } from '@sinclair/typebox'
+import type { HTTPMethod, LocalHook, TypeSchema } from './elysia-fork/types.js'
 
 import deepClone from 'lodash.clonedeep'
 import { z } from 'zod'
@@ -143,14 +139,19 @@ export const registerSchemaPath = ({
 			? [contentType]
 			: contentType ?? ['application/json']
 
-	const bodySchema = hook?.body
+	const bodySchema = getJsonSchema(hook?.body)
 	const paramsSchema = hook?.params
 	// const headerSchema = hook?.headers
 	const querySchema = hook?.query
-	let responseSchema = hook?.response as unknown as OpenAPIV3.ResponsesObject
+	let responseSchema = hook?.response as unknown as TypeSchema
+	let openapiResponse: OpenAPIV3.ResponsesObject = {}
 
 	if (typeof responseSchema === 'object') {
-		if (Kind in responseSchema) {
+		const isStatusMap = Object.keys(responseSchema).every(
+			(key) => typeof key === 'number' || Number.isInteger(Number(key)),
+		)
+		if (!isStatusMap) {
+			let jsonSchema = getJsonSchema(responseSchema)
 			const {
 				type,
 				properties,
@@ -158,13 +159,9 @@ export const registerSchemaPath = ({
 				additionalProperties,
 				patternProperties,
 				...rest
-			} = responseSchema as typeof responseSchema & {
-				type: string
-				properties: Object
-				required: string[]
-			}
+			} = jsonSchema
 
-			responseSchema = {
+			openapiResponse = {
 				'200': {
 					...rest,
 					description: rest.description as any,
@@ -175,71 +172,64 @@ export const registerSchemaPath = ({
 									type,
 									properties,
 									patternProperties,
-									items: responseSchema.items,
+									items: jsonSchema.items,
 									required,
 							  } as any)
-							: responseSchema,
+							: jsonSchema,
 					),
 				},
 			}
 		} else {
-			Object.entries(responseSchema as Record<string, TSchema>).forEach(
-				([key, value]) => {
-					if (typeof value === 'string') {
-						if (!models[value]) return
-
-						// eslint-disable-next-line @typescript-eslint/no-unused-vars
-						const {
-							type,
-							properties,
-							required,
-							additionalProperties: _1,
-							patternProperties: _2,
-							...rest
-						} = models[value] as TSchema & {
-							type: string
-							properties: Object
-							required: string[]
-						}
-
-						responseSchema[key] = {
-							...rest,
-							description: rest.description as any,
-							content: mapTypesResponse(contentTypes, value),
-						}
-					} else {
-						const {
-							type,
-							properties,
-							required,
-							additionalProperties,
-							patternProperties,
-							...rest
-						} = value as typeof value & {
-							type: string
-							properties: Object
-							required: string[]
-						}
-
-						responseSchema[key] = {
-							...rest,
-							description: rest.description as any,
-							content: mapTypesResponse(
-								contentTypes,
-								type === 'object' || type === 'array'
-									? ({
-											type,
-											properties,
-											patternProperties,
-											items: value.items,
-											required,
-									  } as any)
-									: value,
-							),
-						}
+			Object.entries(
+				responseSchema as Record<string, TypeSchema>,
+			).forEach(([key, value]) => {
+				if (typeof value === 'string') {
+					if (!models[value]) return
+
+					// eslint-disable-next-line @typescript-eslint/no-unused-vars
+					const {
+						type,
+						properties,
+						required,
+						additionalProperties: _1,
+						patternProperties: _2,
+						...rest
+					} = getJsonSchema(models[value])
+
+					openapiResponse[key] = {
+						...rest,
+						description: rest.description as any,
+						content: mapTypesResponse(contentTypes, value),
 					}
-				},
-			)
+				} else {
+					const schema = getJsonSchema(value)
+					const {
+						type,
+						properties,
+						required,
+						additionalProperties,
+						patternProperties,
+						...rest
+					} = schema
+
+					openapiResponse[key] = {
+						...rest,
+						description: rest.description as any,
+						content: mapTypesResponse(
+							contentTypes,
+							type === 'object' || type === 'array'
+								? ({
+										type,
+										properties,
+										patternProperties,
+										items: rest.items,
+										required,
+								  } as any)
+								: schema,
+						),
+					}
+				}
+			})
 		}
 	} else if (typeof responseSchema === 'string') {
 		if (!(responseSchema in models)) return
@@ -252,13 +242,9 @@ export const registerSchemaPath = ({
 			additionalProperties: _1,
 			patternProperties: _2,
 			...rest
-		} = models[responseSchema] as TSchema & {
-			type: string
-			properties: Object
-			required: string[]
-		}
+		} = getJsonSchema(models[responseSchema])
 
-		responseSchema = {
+		openapiResponse = {
 			// @ts-ignore
 			'200': {
 				...rest,
@@ -279,9 +265,9 @@ export const registerSchemaPath = ({
 			...((paramsSchema || querySchema || bodySchema
 				? ({ parameters } as any)
 				: {}) satisfies OpenAPIV3.ParameterObject),
-			...(responseSchema
+			...(openapiResponse
 				? {
-						responses: responseSchema,
+						responses: openapiResponse,
 				  }
 				: {}),
 			operationId:
@@ -312,10 +298,10 @@ export const registerSchemaPath = ({
  * @see https://github.com/elysiajs/elysia-swagger
  */
 export const openapi = <Path extends string = '/openapi'>({
-	path,
+	path = '/openapi' as Path,
 	documentation = {},
 }: {
-	path: Path
+	path?: Path
 	/**
 	 * Customize Swagger config, refers to Swagger 2.0 config
 	 *
@@ -326,7 +312,7 @@ export const openapi = <Path extends string = '/openapi'>({
 		| 'x-express-openapi-additional-middleware'
 		| 'x-express-openapi-validation-strict'
 	>
-}) => {
+} = {}) => {
 	const schema = {}
 	let totalRoutes = 0
 
@@ -392,7 +378,7 @@ export const openapi = <Path extends string = '/openapi'>({
 				// 	(tag) => !excludeTags?.includes(tag?.name),
 				// ),
 				info: {
-					title: 'Elysia Documentation',
+					title: 'Spiceflow Documentation',
 					description: 'Development documentation',
 					version: '0.0.0',
 					...documentation.info,
@@ -417,6 +403,7 @@ export const openapi = <Path extends string = '/openapi'>({
 }
 
 function getJsonSchema(schema: TypeSchema): JSONSchemaType<any> {
+	if (!schema) return undefined as any
 	if (isZodSchema(schema)) {
 		let fn = zodToJsonSchema.default ?? zodToJsonSchema
 		let jsonSchema = fn(schema, {})

package/src/spiceflow.ts

@@ -14,6 +14,7 @@ import {
 	HTTPMethod,
 	InlineHandler,
 	InputSchema,
+	IsAny,
 	JoinPath,
 	LocalHook,
 	MaybeArray,
@@ -889,20 +890,8 @@ export class Spiceflow<
 
 	use<const NewSpiceflow extends AnySpiceflow>(
 		instance: NewSpiceflow,
-	): NewSpiceflow['_scoped'] extends false
-		? Spiceflow<
-				BasePath,
-				Scoped,
-				// @ts-expect-error - This is truly ideal
-				Prettify2<Singleton & NewSpiceflow['_types']['Singleton']>,
-				Prettify2<Definitions & NewSpiceflow['_types']['Definitions']>,
-				Prettify2<Metadata & NewSpiceflow['_types']['Metadata']>,
-				BasePath extends ``
-					? Routes & NewSpiceflow['_routes']
-					: Routes & CreateEden<BasePath, NewSpiceflow['_routes']>,
-				Ephemeral,
-				Prettify2<Volatile & NewSpiceflow['_ephemeral']>
-		  >
+	): IsAny<NewSpiceflow> extends true
+		? this
 		: Spiceflow<
 				BasePath,
 				Scoped,
@@ -980,7 +969,7 @@ export class Spiceflow<
 	async handle(request: Request, platform?: P): Promise<Response> {
 		platform ??= {} as P
 
-		let u = new URL(request.url)
+		let u = new URL(request.url, 'http://localhost')
 		let path = u.pathname + u.search
 		const defaultContext = {
 			redirect,

package/src/types.test.ts

@@ -0,0 +1,50 @@
+import { test, describe, expect } from 'vitest'
+import { Type } from '@sinclair/typebox'
+import { bfs, Spiceflow } from './spiceflow.js'
+import { z } from 'zod'
+import { createSpiceflowClient } from './client/index.js'
+import { Prettify } from './elysia-fork/types.js'
+
+test('`use` on non Spiceflow return', async () => {
+	function nonSpiceflowReturn() {
+		return new Spiceflow() as any
+	}
+	const app = new Spiceflow()
+		.use(nonSpiceflowReturn())
+		.post('/xxx', () => 'hi')
+	const res = await app.handle(
+		new Request('http://localhost/xxx', { method: 'POST' }),
+	)
+
+	let client = createSpiceflowClient(app)
+
+	type ClientType = Prettify<typeof client>
+	// @ts-expect-error
+	client.something
+
+	client.xxx.post()
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
+})
+test('`use` on Spiceflow return', async () => {
+	function nonSpiceflowReturn() {
+		return new Spiceflow().post('/usePost', () => 'hi')
+	}
+	const app = new Spiceflow()
+		.use(nonSpiceflowReturn())
+		.post('/xxx', () => 'hi')
+	const res = await app.handle(
+		new Request('http://localhost/xxx', { method: 'POST' }),
+	)
+
+	let client = createSpiceflowClient(app)
+	client.xxx.post()
+	client.usePost.post()
+	
+	type ClientType = Prettify<typeof client>
+	// @ts-expect-error
+	client.something
+
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
+})