Support $ref with sibling keywords (OpenAPI 3.1)

In OpenAPI 3.1, $ref can have sibling keywords like maxLength, minLength,
pattern, etc. Merge sibling constraints into the resolved schema so they
are compiled into the generated validator.

Author: nolannbiron

src/compileValueSchema.ts

@@ -40,7 +40,24 @@ export function compileValueSchema(
     schema: OpenAPIValueSchema,
 ): namedTypes.Identifier {
     if ('$ref' in schema) {
-        return compileValueSchema(compiler, compiler.resolveRef(schema));
+        const resolved = compiler.resolveRef(schema);
+        const { $ref, ...constraints } = schema;
+        if (Object.keys(constraints).length > 0) {
+            // Apply the constraints to the additionalProperties schema if it exists
+            if (
+                resolved.type === 'object' &&
+                typeof resolved.additionalProperties === 'object'
+            ) {
+                return compileValueSchema(compiler, {
+                    ...resolved,
+                    additionalProperties: { ...resolved.additionalProperties, ...constraints },
+                });
+            }
+            // Otherwise merge directly into the resolved schema
+            return compileValueSchema(compiler, { ...resolved, ...constraints });
+        }
+
+        return compileValueSchema(compiler, resolved);
     }
 
     if ('anyOf' in schema) {

src/tests/__snapshots__/compileValueSchema.test.ts.snap

@@ -2007,3 +2007,107 @@ function obj0(path, value, context) {
     return value;
 }"
 `;
+
+exports[`OpenAPI 3.1 $ref with sibling keywords $ref with maxLength 1`] = `
+"/** 
+Validate a request against the OpenAPI spec
+@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 | string | null } }} [context] - Context object to pass to validation functions
+@returns {{ operationId?: string; params: Record<string, string>; query: Record<string, string | string[]>; body?: any; headers: Record<string, string>; }}
+*/
+export function validateRequest(request, context) {
+    return new RequestError(404, 'no operation match path');
+}
+/** 
+Map of all components defined in the spec to their validation functions.
+{Object.<string, <T>(path: string[], value: T, context: any) => (T | ValidationError)>}
+*/
+export const componentSchemas = { 'MyString': obj1 };
+export class RequestError extends Error {
+    /** @param {number} code HTTP code for the error
+@param {string} message The error message*/
+    constructor(code, message) {
+        super(message);
+        /** @type {number} HTTP code for the error*/
+        this.code = code;
+    }
+}
+export class ValidationError extends RequestError {
+    /** @param {string[]} path The path that failed validation
+@param {string} message The error message*/
+    constructor(path, message) {
+        super(409, message);
+        /** @type {string[]} The path that failed validation*/
+        this.path = path;
+    }
+}
+function obj0(path, value, context) {
+    if (typeof value !== 'string') {
+        return new ValidationError(path, 'expected a string');
+    }
+    if (value.length > 64) {
+        return new ValidationError(path, 'expected at most 64 characters');
+    }
+    return value;
+}
+function obj1(path, value, context) {
+    if (typeof value !== 'string') {
+        return new ValidationError(path, 'expected a string');
+    }
+    return value;
+}"
+`;
+
+exports[`OpenAPI 3.1 $ref with sibling keywords $ref with minLength and pattern 1`] = `
+"/** 
+Validate a request against the OpenAPI spec
+@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 | string | null } }} [context] - Context object to pass to validation functions
+@returns {{ operationId?: string; params: Record<string, string>; query: Record<string, string | string[]>; body?: any; headers: Record<string, string>; }}
+*/
+export function validateRequest(request, context) {
+    return new RequestError(404, 'no operation match path');
+}
+/** 
+Map of all components defined in the spec to their validation functions.
+{Object.<string, <T>(path: string[], value: T, context: any) => (T | ValidationError)>}
+*/
+export const componentSchemas = { 'MyString': obj2 };
+export class RequestError extends Error {
+    /** @param {number} code HTTP code for the error
+@param {string} message The error message*/
+    constructor(code, message) {
+        super(message);
+        /** @type {number} HTTP code for the error*/
+        this.code = code;
+    }
+}
+export class ValidationError extends RequestError {
+    /** @param {string[]} path The path that failed validation
+@param {string} message The error message*/
+    constructor(path, message) {
+        super(409, message);
+        /** @type {string[]} The path that failed validation*/
+        this.path = path;
+    }
+}
+const obj1 = new RegExp('^[a-z]+$');
+function obj0(path, value, context) {
+    if (typeof value !== 'string') {
+        return new ValidationError(path, 'expected a string');
+    }
+    if (value.length < 1) {
+        return new ValidationError(path, 'expected at least 1 characters');
+    }
+    if (!obj1.test(value)) {
+        return new ValidationError(path, 'expected to match the pattern "^[a-z]+$"');
+    }
+    return value;
+}
+function obj2(path, value, context) {
+    if (typeof value !== 'string') {
+        return new ValidationError(path, 'expected a string');
+    }
+    return value;
+}"
+`;

src/tests/compileValueSchema.test.ts

@@ -419,4 +419,64 @@ describe('OpenAPI 3.1', () => {
             expect(compiler.compile()).toMatchSnapshot();
         });
     });
+
+    describe('$ref with sibling keywords', () => {
+        test('$ref with maxLength', () => {
+            const compiler = new Compiler({
+                components: {
+                    schemas: {
+                        MyString: { type: 'string' },
+                    },
+                },
+            });
+            compileValueSchema(compiler, {
+                $ref: '#/components/schemas/MyString',
+                maxLength: 64,
+            } as any);
+            expect(compiler.compile()).toMatchSnapshot();
+        });
+
+        test('$ref with minLength and pattern', () => {
+            const compiler = new Compiler({
+                components: {
+                    schemas: {
+                        MyString: { type: 'string' },
+                    },
+                },
+            });
+            compileValueSchema(compiler, {
+                $ref: '#/components/schemas/MyString',
+                minLength: 1,
+                pattern: '^[a-z]+$',
+            } as any);
+            expect(compiler.compile()).toMatchSnapshot();
+        });
+
+        test('$ref with only description does not change output', () => {
+            const compiler = new Compiler({
+                components: {
+                    schemas: {
+                        MyString: { type: 'string' },
+                    },
+                },
+            });
+            compileValueSchema(compiler, {
+                $ref: '#/components/schemas/MyString',
+                description: 'A localized title',
+            } as any);
+
+            const compilerPlain = new Compiler({
+                components: {
+                    schemas: {
+                        MyString: { type: 'string' },
+                    },
+                },
+            });
+            compileValueSchema(compilerPlain, {
+                $ref: '#/components/schemas/MyString',
+            });
+
+            expect(compiler.compile()).toEqual(compilerPlain.compile());
+        });
+    });
 });