diff --git a/src/builder.ts b/src/builder.ts
index d80ae55..1ac7b55 100644
--- a/src/builder.ts
+++ b/src/builder.ts
@@ -1,3 +1,6 @@
+import { isAPIGatewayProxyResult, ServicesWithParseBody, ServicesWithParseParameters } from "@middlewares/proxy";
+import { notFoundError } from "@src/errors";
+import { ok } from "@src/responses";
 import * as awsLambda from "aws-lambda";
 
 export interface LambdaArg<TEvent, TServices> {
@@ -55,3 +58,27 @@ export class LambdaBuildImpl implements LambdaBuilder {
 }
 
 export const lambda = (): LambdaBuilder => new LambdaBuildImpl();
+
+export type ProxyFunc<TServices> =
+  (
+    lambda: { event: awsLambda.APIGatewayProxyEvent, context: awsLambda.Context },
+    services: TServices & ServicesWithParseBody & ServicesWithParseParameters) => Promise<any>;
+
+export const proxy = <TServices = any>(func: ProxyFunc<TServices>)
+  : LambdaExecution<awsLambda.APIGatewayProxyEvent, TServices> => {
+    return async (arg: LambdaArg<awsLambda.APIGatewayProxyEvent, TServices>) => {
+      const result = await func(
+        { context: arg.context, event: arg.event },
+        arg.services as TServices & ServicesWithParseBody & ServicesWithParseParameters);
+
+      if (result && isAPIGatewayProxyResult(result)) {
+        return result;
+      }
+
+      if (result) {
+        return ok(result);
+      } else {
+        throw notFoundError(arg.event.path);
+      }
+    };
+};
diff --git a/src/middlewares/proxy.ts b/src/middlewares/proxy.ts
index c581474..aa6e678 100644
--- a/src/middlewares/proxy.ts
+++ b/src/middlewares/proxy.ts
@@ -112,7 +112,7 @@ export const serializeBodyAsJSON =
     };
   };
 
-export const PARSE_BODY_METHOD = "_parseBody";
+export const PARSE_BODY_METHOD = "parseBody";
 
 export interface ServicesWithParseBody {
   [PARSE_BODY_METHOD](): any;
@@ -169,7 +169,7 @@ export const parseBodyAsFORM = (reviver?: (key: any, value: any) => any, parseMe
   };
 };
 
-export const PARSE_PARAMETERS_METHOD = "_parseParameters";
+export const PARSE_PARAMETERS_METHOD = "parseParameters";
 
 export interface ServicesWithParseParameters {
   [PARSE_PARAMETERS_METHOD](): any;
diff --git a/src/middlewares/validation.ts b/src/middlewares/validation.ts
index 1d3c18b..28ac9cd 100644
--- a/src/middlewares/validation.ts
+++ b/src/middlewares/validation.ts
@@ -33,11 +33,11 @@ export const validateBody = (schema: JSONSchema)
     arg: LambdaArg<awsLambda.APIGatewayProxyEvent, ServicesWithParseBody>,
     next: LambdaExecution<any, any>): Promise<any> => {
 
-    if (!arg.services._parseBody) {
+    if (!arg.services.parseBody) {
       throw new Error("Missing parseBody service - did you forget a middleware?");
     }
 
-    const bodyAsObject = arg.services._parseBody();
+    const bodyAsObject = arg.services.parseBody();
 
     if (!bodyAsObject) {
       throw validationError([{ code: "required", message: "Missing body", target: "body" }]);
@@ -62,11 +62,11 @@ export const validateParameters = (schema: JSONSchema)
     arg: LambdaArg<awsLambda.APIGatewayProxyEvent, ServicesWithParseParameters>,
     next: LambdaExecution<any, any>): Promise<any> => {
 
-    if (!arg.services._parseParameters) {
+    if (!arg.services.parseParameters) {
       throw new Error("Missing parseParameters service - did you forget a middleware?");
     }
 
-    const validationErrors = validate(schema, arg.services._parseParameters(), "parameters");
+    const validationErrors = validate(schema, arg.services.parseParameters(), "parameters");
     if (validationErrors.length > 0) {
       throw validationError(validationErrors);
     }
diff --git a/test/unit/middlewares/proxy-test.ts b/test/unit/middlewares/proxy-test.ts
index ac6fa2e..4438181 100644
--- a/test/unit/middlewares/proxy-test.ts
+++ b/test/unit/middlewares/proxy-test.ts
@@ -199,7 +199,7 @@ describe("parseBodyAsJSON middleware", () => {
       .use(parseBodyAsJSON())
       .handler<any, APIGatewayProxyResult, ServicesWithParseBody>
         (async ({ services }) => {
-          expect(services._parseBody()).to.deep.equal(body);
+          expect(services.parseBody()).to.deep.equal(body);
         });
 
     await handler(
@@ -223,7 +223,7 @@ describe("parseBodyAsFORM middleware", () => {
       .use(parseBodyAsFORM())
       .handler<any, APIGatewayProxyResult, ServicesWithParseBody>
         (async ({ services }) => {
-          expect(services._parseBody()).to.deep.equal(body);
+          expect(services.parseBody()).to.deep.equal(body);
         });
 
     await handler(
@@ -248,7 +248,7 @@ describe("parseParameters middleware", () => {
       .use(parseParameters())
       .handler<any, APIGatewayProxyResult, ServicesWithParseParameters>
         (async ({ services }) => {
-          expect(services._parseParameters()).to.deep.equal(parameters);
+          expect(services.parseParameters()).to.deep.equal(parameters);
         });
 
     await handler(