Start processing path and operations

Author: SamyPesse

src/compileOperation.ts

@@ -5,7 +5,6 @@ import { OpenAPIOperation } from "./types";
 import { compileValueSchema } from './compileValueSchema';
 import { ValidationErrorIdentifier } from './error';
 
-
 /**
  * Compile an operation into a function.
  * The value input is an object:
@@ -89,7 +88,6 @@ export function compileOperation(compiler: Compiler, operation: OpenAPIOperation
                     ])
                 ));
             }
-
         } else {
             nodes.push(builders.ifStatement(
                 builders.binaryExpression(

src/compilePath.ts

@@ -0,0 +1,57 @@
+import { namedTypes, builders } from 'ast-types';
+
+import { Compiler } from "./compiler";
+import { OpenAPIPath } from "./types";
+import { compileValueSchema } from './compileValueSchema';
+import { ValidationErrorIdentifier } from './error';
+import { compileOperation } from './compileOperation';
+
+/**
+ * Compile a path into a function.
+ * The value input is an object:
+ * {
+ *   path: string;
+ *   method: string;
+ *   body: any;
+ *   query: any;
+ *   headers: any;
+ * }
+ */
+export function compilePath(compiler: Compiler, pathOperations: OpenAPIPath) {
+    return compiler.defineValidationFunction(pathOperations, ({ value, path, error }) => {
+        const nodes: namedTypes.BlockStatement['body'] = [];
+
+        Object.entries(pathOperations).forEach(([method, operation]) => {
+            const fnOperation = compileOperation(compiler, operation);
+
+            nodes.push(
+                builders.ifStatement(
+                    builders.binaryExpression(
+                        '===',
+                        builders.memberExpression(
+                            value,
+                            builders.identifier('method'),
+                        ),
+                        builders.literal(method),
+                    ),
+                    builders.blockStatement([
+                        builders.returnStatement(
+                            builders.callExpression(fnOperation, [
+                                path,
+                                value,
+                            ]),
+                        ),
+                    ]),
+                )
+            )
+        });
+
+        nodes.push(
+            builders.returnStatement(
+                error('method not supported')
+            ),
+        )
+
+        return nodes;
+    });
+}

src/hash.ts

@@ -23,6 +23,12 @@ const PRESERVE_PROPS = [
     'additionalProperties',
     'minProperties',
     'maxProperties',
+    'requestBody',
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
 ]
 
 /**

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

@@ -0,0 +1,64 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`with get and post 1`] = `
+"class ValidationError {
+    constructor(path, message) {
+        super(message);
+        this.path = path;
+    }
+}
+function obj1(path, value) {
+    if (value.body !== undefined) {
+        return new ValidationError(path, 'body is not allowed');
+    }
+    return value;
+}
+function obj4(path, value) {
+    if (!(typeof value === 'number')) {
+        return new ValidationError(path, 'Expected a number');
+    }
+    return value;
+}
+function obj3(path, value) {
+    const keys = new Set(Object.keys(value));
+    const value0 = value['foo'];
+    if (value0 !== undefined) {
+        const result0 = obj4([
+            ...path,
+            'foo'
+        ], value0);
+        if (result0 instanceof ValidationError) {
+            return result0;
+        }
+        value['foo'] = result0;
+    }
+    if (keys.size > 0) {
+        return new ValidationError(path, 'Unexpected properties');
+    }
+    return value;
+}
+function obj2(path, value) {
+    if (value.body === undefined) {
+        return new ValidationError(path, 'body is required');
+    }
+    const body = obj3([
+        ...path,
+        'body'
+    ], value.body);
+    if (body instanceof ValidationError) {
+        return body;
+    } else {
+        value.body = body;
+    }
+    return value;
+}
+function obj0(path, value) {
+    if (value.method === 'get') {
+        return obj1(path, value);
+    }
+    if (value.method === 'post') {
+        return obj2(path, value);
+    }
+    return new ValidationError(path, 'method not supported');
+}"
+`;

src/tests/compileOperation.test.ts

@@ -27,7 +27,6 @@ describe('With body', () => {
                 },
             }
         });
-        console.log(compiler.compile());
         expect(compiler.compile()).toMatchSnapshot();
     });
 });

src/tests/compilePath.test.ts

@@ -0,0 +1,38 @@
+import { Compiler } from '../compiler';
+import { compilePath } from '../compilePath';
+
+test('with get and post', () => {
+    const compiler = new Compiler();
+    compilePath(compiler, {
+        get: {
+            parameters: [
+                {
+                    name: 'foo',
+                    in: 'query',
+                    schema: {
+                        type: 'number',
+                    },
+                },
+            ]
+        },
+        post: {
+            requestBody: {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                foo: {
+                                    type: 'number',
+                                },
+                            },
+                        },
+                    },
+                },
+            }
+        }
+    });
+    console.log(compiler.compile());
+    expect(compiler.compile()).toMatchSnapshot();
+});