Add support for checking format against context

Author: SamyPesse

README.md

@@ -20,8 +20,6 @@ openapi-static-validator spec.json > validate.js
     -   [ ] in `cookie`
     -   [ ] in `header`
     -   [ ] in `query`
--   JSONSchema `string` validation of:
-    -   [ ] `format`
 -   JSONSchema `integer`
     -   [ ] no float
 

src/compileValueSchema.ts

@@ -622,7 +622,7 @@ function compileNumberSchema(
 }
 
 function compileStringSchema(compiler: Compiler, schema: OpenAPIStringSchema) {
-    return compiler.declareValidationFunction(schema, ({ value, error }) => {
+    return compiler.declareValidationFunction(schema, ({ value, context, path, error }) => {
         const enumCheck = compileEnumableCheck(compiler, schema, value, error);
         if (enumCheck) {
             return enumCheck;
@@ -641,6 +641,44 @@ function compileStringSchema(compiler: Compiler, schema: OpenAPIStringSchema) {
             ),
         );
 
+        // Validate the format using the potential `context?.formatString?.[schema.format]`
+        if (schema.format) {
+            const formatResult = builders.identifier('formatResult');
+
+            nodes.push(
+                builders.variableDeclaration('const', [
+                    builders.variableDeclarator(
+                        formatResult,
+                        builders.callExpression.from({
+                            callee: builders.memberExpression.from({
+                                object: builders.memberExpression.from({
+                                    object: context,
+                                    property: builders.identifier('formatString'),
+                                    optional: true,
+                                }),
+                                property: builders.literal(schema.format),
+                                computed: true,
+                                optional: true,
+                            }),
+                            optional: true,
+                            arguments: [value, path],
+                        }),
+                    ),
+                ]),
+            );
+
+            nodes.push(
+                builders.ifStatement(
+                    builders.binaryExpression(
+                        'instanceof',
+                        formatResult,
+                        ValidationErrorIdentifier,
+                    ),
+                    builders.blockStatement([builders.returnStatement(formatResult)]),
+                ),
+            );
+        }
+
         if (schema.minLength) {
             nodes.push(
                 builders.ifStatement(

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

@@ -157,6 +157,40 @@ function obj0(path, value, context) {
 }"
 `;
 
+exports[`String with pattern 2`] = `
+"/**
+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 {{ 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>; }}
+*/
+export function validateRequest(request, context) {
+    return new RequestError(404, 'no operation match path');
+}
+export class RequestError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class ValidationError extends RequestError {
+    constructor(path, message) {
+        super(409, message);
+        this.path = path;
+    }
+}
+function obj0(path, value, context) {
+    if (typeof value !== 'string') {
+        return new ValidationError(path, 'Expected a string');
+    }
+    const formatResult = context?.formatString?.['uri']?.(value, path);
+    if (formatResult instanceof ValidationError) {
+        return formatResult;
+    }
+    return value;
+}"
+`;
+
 exports[`Objects with a required prop 1`] = `
 "/**
 Validate a request against the OpenAPI spec

src/tests/compileValueSchema.test.ts

@@ -52,6 +52,15 @@ describe('String', () => {
         });
         expect(compiler.compile()).toMatchSnapshot();
     });
+
+    test('with pattern', () => {
+        const compiler = new Compiler();
+        compileValueSchema(compiler, {
+            type: 'string',
+            format: 'uri',
+        });
+        expect(compiler.compile()).toMatchSnapshot();
+    });
 });
 
 describe('Objects', () => {