moonflower 1.4.3 → 1.4.5

package/src/hooks/useQueryParams.spec.ts

@@ -321,4 +321,275 @@ describe('useQueryParams', () => {
 			expectTypeOf(params.numberParam).toEqualTypeOf<number | undefined>()
 		})
 	})
+
+	describe('legacy array validators', () => {
+		it('parses JSON string array with legacy validator', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: JSON.stringify(['node1', 'node2']),
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: RequiredParam<string[]>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2'])
+		})
+
+		it('parses comma-separated array with legacy validator', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'node1,node2,node3',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: RequiredParam<string[]>({
+					parse: (v) => String(v).split(','),
+				}),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2', 'node3'])
+		})
+
+		it('fails validation on invalid legacy array param', () => {
+			const test = () => {
+				const ctx = mockContextQuery(mockContext(), {
+					nodes: 'not valid json array',
+				})
+
+				useQueryParams(ctx, {
+					nodes: RequiredParam<string[]>({
+						parse: (v) => JSON.parse(String(v)),
+					}),
+				})
+			}
+
+			expect(test).toThrow(ValidationError)
+			expect(test).toThrow("Failed query param validation: 'nodes'")
+		})
+
+		it('allows missing optional legacy array param', () => {
+			const ctx = mockContextQuery(mockContext(), {})
+
+			const params = useQueryParams(ctx, {
+				nodes: OptionalParam<string[]>({
+					parse: (v) => JSON.parse(String(v)),
+				}),
+			})
+
+			expect(params.nodes).toEqual(undefined)
+		})
+	})
+
+	describe('zod array validators', () => {
+		it('parses JSON string array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: JSON.stringify(['node1', 'node2']),
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2'])
+		})
+
+		it('parses JSON number array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				ids: JSON.stringify([1, 2, 3]),
+			})
+
+			const params = useQueryParams(ctx, {
+				ids: z.array(z.number()),
+			})
+
+			expect(params.ids).toEqual([1, 2, 3])
+		})
+
+		it('parses JSON object array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				items: JSON.stringify([
+					{ name: 'first', value: 1 },
+					{ name: 'second', value: 2 },
+				]),
+			})
+
+			const params = useQueryParams(ctx, {
+				items: z.array(z.object({ name: z.string(), value: z.number() })),
+			})
+
+			expect(params.items).toEqual([
+				{ name: 'first', value: 1 },
+				{ name: 'second', value: 2 },
+			])
+		})
+
+		it('parses comma-separated string array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'node1,node2,node3',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2', 'node3'])
+		})
+
+		it('parses comma-separated number array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				ids: '1,2,3',
+			})
+
+			const params = useQueryParams(ctx, {
+				ids: z.array(z.number()),
+			})
+
+			expect(params.ids).toEqual([1, 2, 3])
+		})
+
+		it('parses comma-separated boolean array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				flags: 'true,false,true',
+			})
+
+			const params = useQueryParams(ctx, {
+				flags: z.array(z.boolean()),
+			})
+
+			expect(params.flags).toEqual([true, false, true])
+		})
+
+		it('parses comma-separated values with whitespace', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'node1, node2 , node3',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2', 'node3'])
+		})
+
+		it('parses single value as string array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'single',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()),
+			})
+
+			expect(params.nodes).toEqual(['single'])
+		})
+
+		it('parses single value as number array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				ids: '42',
+			})
+
+			const params = useQueryParams(ctx, {
+				ids: z.array(z.number()),
+			})
+
+			expect(params.ids).toEqual([42])
+		})
+
+		it('fails validation on invalid array element', () => {
+			const test = () => {
+				const ctx = mockContextQuery(mockContext(), {
+					ids: 'abc,def',
+				})
+
+				useQueryParams(ctx, {
+					ids: z.array(z.number()),
+				})
+			}
+
+			expect(test).toThrow(ValidationError)
+			expect(test).toThrow("Failed query param validation: 'ids'")
+		})
+
+		it('fails when required array is missing', () => {
+			const test = () => {
+				const ctx = mockContextQuery(mockContext(), {})
+
+				useQueryParams(ctx, {
+					nodes: z.array(z.string()),
+				})
+			}
+
+			expect(test).toThrow(ValidationError)
+			expect(test).toThrow("Missing query params: 'nodes'")
+		})
+
+		it('parses optional array when missing', () => {
+			const ctx = mockContextQuery(mockContext(), {})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()).optional(),
+			})
+
+			expect(params.nodes).toEqual(undefined)
+		})
+
+		it('parses optional array when present', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'node1,node2',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()).optional(),
+			})
+
+			expect(params.nodes).toEqual(['node1', 'node2'])
+		})
+
+		it('infers return type of string array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				nodes: 'a,b',
+			})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()),
+			})
+
+			expectTypeOf(params.nodes).toEqualTypeOf<string[]>()
+		})
+
+		it('infers return type of number array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				ids: '1,2',
+			})
+
+			const params = useQueryParams(ctx, {
+				ids: z.array(z.number()),
+			})
+
+			expectTypeOf(params.ids).toEqualTypeOf<number[]>()
+		})
+
+		it('infers return type of object array', () => {
+			const ctx = mockContextQuery(mockContext(), {
+				items: JSON.stringify([{ name: 'a' }]),
+			})
+
+			const params = useQueryParams(ctx, {
+				items: z.array(z.object({ name: z.string() })),
+			})
+
+			expectTypeOf(params.items).toEqualTypeOf<{ name: string }[]>()
+		})
+
+		it('infers return type of optional array', () => {
+			const ctx = mockContextQuery(mockContext(), {})
+
+			const params = useQueryParams(ctx, {
+				nodes: z.array(z.string()).optional(),
+			})
+
+			expectTypeOf(params.nodes).toEqualTypeOf<string[] | undefined>()
+		})
+	})
 })

package/src/openapi/analyzerModule/nodeParsers.ts

@@ -308,19 +308,31 @@ const getZodCallShape = (node: Node): ShapeOfType['shape'] => {
 
 	if (typeName === 'ZodArray') {
 		const argNode = callExpression.getFirstChildByKind(SyntaxKind.SyntaxList)?.getFirstChild()
-		if (!argNode) {
-			return 'unknown_zod_array'
+		if (argNode) {
+			const elementShape = isZodCallExpression(argNode)
+				? getZodCallShape(argNode)
+				: getValidatorPropertyShape(argNode)
+			return [
+				{
+					role: 'array' as const,
+					shape: elementShape,
+					optional: false,
+				},
+			]
 		}
-		const elementShape = isZodCallExpression(argNode)
-			? getZodCallShape(argNode)
-			: getValidatorPropertyShape(argNode)
-		return [
-			{
-				role: 'array' as const,
-				shape: elementShape,
-				optional: false,
-			},
-		]
+		// Handle chained form: z.string().array()
+		const propertyAccess = callExpression.getFirstChildByKind(SyntaxKind.PropertyAccessExpression)
+		const receiverCall = propertyAccess?.getFirstChildByKind(SyntaxKind.CallExpression)
+		if (receiverCall && isZodCallExpression(receiverCall)) {
+			return [
+				{
+					role: 'array' as const,
+					shape: getZodCallShape(receiverCall),
+					optional: false,
+				},
+			]
+		}
+		return 'unknown_zod_array'
 	}
 
 	if (typeName === 'ZodEnum') {

package/src/openapi/analyzerModule/test/TestCase.ts

@@ -7,6 +7,10 @@ export const TestCase = {
 	parsesInlineZodEnum: 'parses-inline-zod-enum',
 	parsesZodOptional: 'parses-zod-optional',
 	parsesAliasedZodSchema: 'parses-aliased-zod-schema',
+	parsesZodQueryStringArray: 'parses-zod-query-string-array',
+	parsesZodQueryNumberArray: 'parses-zod-query-number-array',
+	parsesZodQueryObjectArray: 'parses-zod-query-object-array',
+	parsesZodQueryOptionalArray: 'parses-zod-query-optional-array',
 	parsesReturnRecordStringUnknown: 'parses-return-record-string-unknown',
 	parsesReturnObjectWithRecordProperty: 'parses-return-object-with-record-property',
 	parsesBufferReturnedFromFunction: 'parses-buffer-returned-from-function',

package/src/openapi/analyzerModule/test/openApiAnalyzer.zod.spec.data.ts

@@ -3,6 +3,7 @@ import { z } from 'zod'
 import { z as valibot } from 'zod'
 
 import { usePathParams } from '../../../hooks/usePathParams'
+import { useQueryParams } from '../../../hooks/useQueryParams'
 import { useRequestBody } from '../../../hooks/useRequestBody'
 import { Router } from '../../../router/Router'
 import { OptionalParam } from '../../../validators/ParamWrappers'
@@ -116,3 +117,33 @@ router.post(`/test/${TestCase.parsesZodOptional}`, (ctx) => {
 		optionalNumber: z.number().optional(),
 	})
 })
+
+router.get(`/test/${TestCase.parsesZodQueryStringArray}`, (ctx) => {
+	useQueryParams(ctx, {
+		tags: z.array(z.string()),
+		otherTags: z.string().array(),
+	})
+})
+
+router.get(`/test/${TestCase.parsesZodQueryNumberArray}`, (ctx) => {
+	useQueryParams(ctx, {
+		ids: z.array(z.number()),
+	})
+})
+
+router.get(`/test/${TestCase.parsesZodQueryObjectArray}`, (ctx) => {
+	useQueryParams(ctx, {
+		items: z.array(
+			z.object({
+				name: z.string(),
+				value: z.number(),
+			}),
+		),
+	})
+})
+
+router.get(`/test/${TestCase.parsesZodQueryOptionalArray}`, (ctx) => {
+	useQueryParams(ctx, {
+		tags: z.array(z.string()).optional(),
+	})
+})

package/src/openapi/analyzerModule/test/openApiAnalyzer.zod.spec.ts

@@ -237,6 +237,84 @@ describe('OpenApi Analyzer (Zod Validator)', () => {
 				])
 				expect(endpoint.objectBody[0].optional).toEqual(false)
 			})
+
+			it('parses zod query string array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesZodQueryStringArray)
+
+				expect(endpoint.requestQuery[0].identifier).toEqual('tags')
+				expect(endpoint.requestQuery[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'string',
+						optional: false,
+					},
+				])
+				expect(endpoint.requestQuery[0].optional).toEqual(false)
+				expect(endpoint.requestQuery[1].identifier).toEqual('otherTags')
+				expect(endpoint.requestQuery[1].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'string',
+						optional: false,
+					},
+				])
+				expect(endpoint.requestQuery[1].optional).toEqual(false)
+			})
+
+			it('parses zod query number array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesZodQueryNumberArray)
+
+				expect(endpoint.requestQuery[0].identifier).toEqual('ids')
+				expect(endpoint.requestQuery[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'number',
+						optional: false,
+					},
+				])
+				expect(endpoint.requestQuery[0].optional).toEqual(false)
+			})
+
+			it('parses zod query object array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesZodQueryObjectArray)
+
+				expect(endpoint.requestQuery[0].identifier).toEqual('items')
+				expect(endpoint.requestQuery[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: [
+							{
+								identifier: 'name',
+								optional: false,
+								role: 'property',
+								shape: 'string',
+							},
+							{
+								identifier: 'value',
+								optional: false,
+								role: 'property',
+								shape: 'number',
+							},
+						],
+						optional: false,
+					},
+				])
+				expect(endpoint.requestQuery[0].optional).toEqual(false)
+			})
+
+			it('parses zod query optional array validators', () => {
+				const endpoint = analyzeEndpointById(TestCase.parsesZodQueryOptionalArray)
+
+				expect(endpoint.requestQuery[0].identifier).toEqual('tags')
+				expect(endpoint.requestQuery[0].signature).toEqual([
+					{
+						role: 'array',
+						shape: 'string',
+						optional: false,
+					},
+				])
+				expect(endpoint.requestQuery[0].optional).toEqual(true)
+			})
 		})
 	})
 })

package/src/validators/validateParam.ts

@@ -36,13 +36,29 @@ function runPrevalidator(validator: ValidatorUnion, value: string | number | boo
 	return true
 }
 
+function isZodArrayValidator(validator: z.ZodType): boolean {
+	if (validator instanceof z.ZodArray) return true
+	if (validator instanceof z.ZodOptional) return validator.unwrap() instanceof z.ZodArray
+	return false
+}
+
 function runParser(validator: ValidatorUnion, value: string | number | boolean | object | null) {
 	// Zod validator
 	if (validator instanceof z.ZodType) {
+		const isArrayValidator = isZodArrayValidator(validator)
 		const coercedValue = (() => {
+			if (typeof value !== 'string') return value
+
 			try {
-				return typeof value === 'string' ? JSON.parse(value) : value
+				const parsed = JSON.parse(value)
+				if (isArrayValidator && !Array.isArray(parsed)) {
+					return coerceCommaSeparatedToArray(value)
+				}
+				return parsed
 			} catch {
+				if (isArrayValidator) {
+					return coerceCommaSeparatedToArray(value)
+				}
 				return value
 			}
 		})()
@@ -52,6 +68,17 @@ function runParser(validator: ValidatorUnion, value: string | number | boolean |
 	return validator.parse(getValueAsNullableString(value))
 }
 
+function coerceCommaSeparatedToArray(value: string): unknown[] {
+	return value.split(',').map((element) => {
+		const trimmed = element.trim()
+		try {
+			return JSON.parse(trimmed)
+		} catch {
+			return trimmed
+		}
+	})
+}
+
 function runValidator(validator: ValidatorUnion, parsedValue: unknown) {
 	// Legacy validator
 	if ('validate' in validator && typeof validator.validate === 'function') {