Accept string value as array

Author: gregberge

bun.lockb

@@ -140,11 +140,12 @@ export function compileOperation(
             const parameter = compiler.resolveMaybeRef(refParameter);
             const paramValueIdentifier = builders.identifier(`queryParam${index}`);
             const resultIdentifier = builders.identifier(`queryParamResult${index}`);
+
             const schemaFn = compileValueSchema(compiler, parameter.schema);
 
             // Assign the query parameter to a variable
             nodes.push(
-                builders.variableDeclaration('const', [
+                builders.variableDeclaration('let', [
                     builders.variableDeclarator(
                         paramValueIdentifier,
                         builders.memberExpression(
@@ -180,7 +181,7 @@ export function compileOperation(
                     ),
                     builders.blockStatement([
                         // Validate the value
-                        builders.variableDeclaration('const', [
+                        builders.variableDeclaration('let', [
                             builders.variableDeclarator(
                                 resultIdentifier,
                                 builders.callExpression(schemaFn, [
@@ -193,14 +194,59 @@ export function compileOperation(
                                 ]),
                             ),
                         ]),
-                        // Fail if error
+                        // If the result is an error, and try with an array
                         builders.ifStatement(
-                            builders.binaryExpression(
-                                'instanceof',
-                                resultIdentifier,
-                                ValidationErrorIdentifier,
+                            builders.logicalExpression(
+                                '&&',
+                                // "instanceof ValidationError"
+                                builders.binaryExpression(
+                                    'instanceof',
+                                    resultIdentifier,
+                                    ValidationErrorIdentifier,
+                                ),
+                                // typeof paramValue === 'string'
+                                builders.binaryExpression(
+                                    '===',
+                                    builders.unaryExpression('typeof', paramValueIdentifier),
+                                    builders.literal('string'),
+                                ),
                             ),
-                            builders.blockStatement([builders.returnStatement(resultIdentifier)]),
+                            builders.blockStatement([
+                                // paramValue = [paramValue]
+                                builders.expressionStatement(
+                                    builders.assignmentExpression(
+                                        '=',
+                                        paramValueIdentifier,
+                                        builders.arrayExpression([paramValueIdentifier]),
+                                    ),
+                                ),
+                                // result = schemaFn(['query', parameter.name], asArray, context)
+                                builders.expressionStatement(
+                                    builders.assignmentExpression(
+                                        '=',
+                                        resultIdentifier,
+                                        builders.callExpression(schemaFn, [
+                                            builders.arrayExpression([
+                                                builders.literal('query'),
+                                                builders.literal(parameter.name),
+                                            ]),
+                                            paramValueIdentifier,
+                                            contextIdentifier,
+                                        ]),
+                                    ),
+                                ),
+                                // If result is an error, return it
+                                builders.ifStatement(
+                                    builders.binaryExpression(
+                                        'instanceof',
+                                        resultIdentifier,
+                                        ValidationErrorIdentifier,
+                                    ),
+                                    builders.blockStatement([
+                                        builders.returnStatement(resultIdentifier),
+                                    ]),
+                                ),
+                            ]),
                         ),
                         // Otherwise assign the value
                         builders.expressionStatement(

src/compileOperation.ts

@@ -9,9 +9,9 @@ import { annotateWithJSDocComment } from './comments';
 
 const COMMENT = `
 Validate a request against the OpenAPI spec
-@param {{ method: string; path: string; body?: any; query: Record<string, string>; headers: Record<string, string>; }} request - Input request to validate
+@param {{ method: string; path: string; body?: any; query: Record<string, string | string[]>; headers: Record<string, string>; }} request - Input request to validate
 @param {{ stringFormats?: { [format: string]: (value: string, path: string[]) => ValidationError | null } }} [context] - Context object to pass to validation functions
-@returns {{ operationId?: string; params: Record<string, string>; query: Record<string, string>; body?: any; headers: Record<string, string>; }}
+@returns {{ operationId?: string; params: Record<string, string>; query: Record<string, string | string[]>; body?: any; headers: Record<string, string>; }}
 `;
 
 /**