vovk 0.0.0 → 0.0.1

package/Segment.d.ts

@@ -0,0 +1,31 @@
+import type { NextRequest } from 'next/server';
+import { _HttpMethod as HttpMethod, type _RouteHandler as RouteHandler } from './types';
+export declare class _Segment {
+    #private;
+    _routes: Record<HttpMethod, Map<{
+        name?: string;
+        _prefix?: string;
+        _activated?: true;
+    }, Record<string, RouteHandler>>>;
+    GET: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    POST: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    PUT: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    PATCH: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    DELETE: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    HEAD: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+    OPTIONS: (req: NextRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response | undefined>;
+}

package/Segment.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Segment = void 0;
+const types_1 = require("./types");
+const HttpException_1 = require("./HttpException");
+class _Segment {
+    _routes = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = (req, data) => this.#callMethod(types_1._HttpMethod.GET, req, data.params);
+    POST = (req, data) => this.#callMethod(types_1._HttpMethod.POST, req, data.params);
+    PUT = (req, data) => this.#callMethod(types_1._HttpMethod.PUT, req, data.params);
+    PATCH = (req, data) => this.#callMethod(types_1._HttpMethod.PATCH, req, data.params);
+    DELETE = (req, data) => this.#callMethod(types_1._HttpMethod.DELETE, req, data.params);
+    HEAD = (req, data) => this.#callMethod(types_1._HttpMethod.HEAD, req, data.params);
+    OPTIONS = (req, data) => this.#callMethod(types_1._HttpMethod.OPTIONS, req, data.params);
+    #respond = (status, body) => {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    };
+    #respondWithError = (statusCode, message) => {
+        return this.#respond(statusCode, {
+            statusCode,
+            message,
+            isError: true,
+        });
+    };
+    #callMethod = async (httpMethod, req, params) => {
+        const controllers = this._routes[httpMethod];
+        const methodParams = {};
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const handlers = Object.fromEntries([...controllers.entries()]
+            .map(([controller, staticMethods]) => {
+            const prefix = controller._prefix ?? '';
+            if (!controller._activated) {
+                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Controller "${controller.name}" found but not activated`);
+            }
+            return Object.entries(staticMethods).map(([path, staticMethod]) => {
+                const fullPath = [prefix, path].filter(Boolean).join('/');
+                return [fullPath, { staticMethod, controller }];
+            });
+        })
+            .flat());
+        const getHandler = () => {
+            if (Object.keys(params).length === 0) {
+                return handlers[''];
+            }
+            const path = params[Object.keys(params)[0]];
+            const allMethodKeys = Object.keys(handlers);
+            let methodKeys = [];
+            methodKeys = allMethodKeys
+                // First, try to match literal routes exactly.
+                .filter((p) => {
+                if (p.includes(':'))
+                    return false; // Skip parameterized paths
+                return p === path.join('/');
+            });
+            if (!methodKeys.length) {
+                methodKeys = allMethodKeys.filter((p) => {
+                    const routeSegments = p.split('/');
+                    if (routeSegments.length !== path.length)
+                        return false;
+                    for (let i = 0; i < routeSegments.length; i++) {
+                        const routeSegment = routeSegments[i];
+                        const pathSegment = path[i];
+                        if (routeSegment.startsWith(':')) {
+                            const parameter = routeSegment.slice(1);
+                            if (parameter in methodParams) {
+                                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
+                            }
+                            // If it's a parameterized segment, capture the parameter value.
+                            methodParams[parameter] = pathSegment;
+                        }
+                        else if (routeSegment !== pathSegment) {
+                            // If it's a literal segment and it does not match the corresponding path segment, return false.
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            if (methodKeys.length > 1) {
+                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+            }
+            const [methodKey] = methodKeys;
+            if (methodKey) {
+                return handlers[methodKey];
+            }
+            return null;
+        };
+        const handler = getHandler();
+        if (!handler) {
+            return this.#respondWithError(types_1._HttpStatus.NOT_FOUND, 'Route is not found');
+        }
+        const { staticMethod, controller } = handler;
+        try {
+            const result = await staticMethod.call(this, req, methodParams);
+            if (result instanceof Response) {
+                return result;
+            }
+            if (typeof result !== 'undefined') {
+                return this.#respond(200, result);
+            }
+        }
+        catch (e) {
+            const err = e;
+            try {
+                controller._onError?.(err);
+            }
+            catch (onErrorError) {
+                // eslint-disable-next-line no-console
+                console.error(onErrorError);
+            }
+            if (err.message !== 'NEXT_REDIRECT') {
+                const statusCode = err.statusCode ?? types_1._HttpStatus.INTERNAL_SERVER_ERROR;
+                return this.#respondWithError(statusCode, err.message);
+            }
+            throw e; // if NEXT_REDIRECT rethrow it
+        }
+    };
+}
+exports._Segment = _Segment;

package/StreamResponse.d.ts

@@ -0,0 +1,16 @@
+import { _KnownAny as KnownAny, _StreamAbortMessage as StreamAbortMessage } from './types';
+export declare class _StreamResponse<T> extends Response {
+    static readonly JSON_DIVIDER = "__##DIV123##__";
+    static defaultHeaders: {
+        'Content-Type': string;
+        Connection: string;
+        'Content-Encoding': string;
+        'Cache-Control': string;
+    };
+    readonly writer: WritableStreamDefaultWriter;
+    readonly encoder: TextEncoder;
+    constructor(init?: ResponseInit);
+    send(data: T | StreamAbortMessage): Promise<void>;
+    close(): Promise<void>;
+    throw(e: KnownAny): Promise<void>;
+}

package/StreamResponse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._StreamResponse = void 0;
+class _StreamResponse extends Response {
+    static JSON_DIVIDER = '__##DIV123##__'; // protects collisions with JSON data
+    static defaultHeaders = {
+        'Content-Type': 'text/event-stream',
+        Connection: 'keep-alive',
+        'Content-Encoding': 'none',
+        'Cache-Control': 'no-cache, no-transform',
+    };
+    writer;
+    encoder;
+    constructor(init) {
+        const responseStream = new TransformStream();
+        const writer = responseStream.writable.getWriter();
+        const encoder = new TextEncoder();
+        super(responseStream.readable, {
+            ...init,
+            headers: init?.headers ?? _StreamResponse.defaultHeaders,
+        });
+        this.writer = writer;
+        this.encoder = encoder;
+    }
+    send(data) {
+        const { writer, encoder } = this;
+        return writer.write(encoder.encode(JSON.stringify(data) + _StreamResponse.JSON_DIVIDER));
+    }
+    close() {
+        const { writer } = this;
+        return writer.close();
+    }
+    async throw(e) {
+        const { writer } = this;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        await this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        return writer.abort(e);
+    }
+}
+exports._StreamResponse = _StreamResponse;

package/client/clientizeController.d.ts

@@ -0,0 +1,3 @@
+import { type _VovkControllerMetadataJson as VovkControllerMetadataJson } from '../types';
+import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient } from './types';
+export declare const _clientizeController: <T, OPTS extends Record<string, any> = Record<string, never>>(givenController: VovkControllerMetadataJson, options?: VovkClientOptions<OPTS> | undefined) => VovkClient<T, OPTS>;

package/client/clientizeController.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._clientizeController = void 0;
+const defaultStreamFetcher_1 = require("./defaultStreamFetcher");
+const _1 = require(".");
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    for (const [key, value] of Object.entries(params ?? {})) {
+        result = result.replace(`:${key}`, value);
+    }
+    const searchParams = new URLSearchParams();
+    let hasQuery = false;
+    for (const [key, value] of Object.entries(query ?? {})) {
+        searchParams.set(key, value);
+        hasQuery = true;
+    }
+    return `${result}${hasQuery ? '?' : ''}${searchParams.toString()}`;
+};
+const _clientizeController = (givenController, options) => {
+    const controller = givenController;
+    const client = {};
+    if (!controller)
+        throw new Error(`Unable to clientize. Controller metadata is not provided`);
+    const metadata = controller._handlers;
+    if (!metadata)
+        throw new Error(`Unable to clientize. No metadata for controller ${String(controller?.controllerName)}`);
+    const prefix = trimPath(controller._prefix ?? '');
+    const { fetcher = _1.defaultFetcher, streamFetcher = defaultStreamFetcher_1._defaultStreamFetcher } = options ?? {};
+    for (const [staticMethodName, { path, httpMethod, clientValidators }] of Object.entries(metadata)) {
+        const getPath = (params, query) => getHandlerPath([prefix, path].filter(Boolean).join('/'), params, query);
+        const validate = ({ body, query }) => {
+            if (options?.disableClientValidation)
+                return;
+            return options?.validateOnClient?.({ body, query }, clientValidators ?? {});
+        };
+        const handler = (input = {}) => {
+            const internalOptions = {
+                name: staticMethodName,
+                httpMethod,
+                getPath,
+                validate,
+            };
+            const internalInput = {
+                ...input,
+                body: input.body ?? null,
+                query: input.query ?? {},
+                params: input.params ?? {},
+                ...options?.defaultOptions,
+            };
+            if (input.isStream) {
+                if (!streamFetcher)
+                    throw new Error('Stream fetcher is not provided');
+                const fetcherPromise = streamFetcher(internalOptions, internalInput);
+                return fetcherPromise;
+            }
+            const fetcherPromise = fetcher(internalOptions, internalInput);
+            if (!(fetcherPromise instanceof Promise))
+                throw new Error('Fetcher must return a promise');
+            return fetcherPromise;
+        };
+        // @ts-expect-error TODO: Fix this
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports._clientizeController = _clientizeController;

package/client/defaultFetcher.d.ts

@@ -0,0 +1,7 @@
+import { type _VovkClientFetcher as VovkClientFetcher } from './types';
+export interface _DefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
+    prefix?: string;
+    isStream?: boolean;
+}
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultFetcher";
+export declare const _defaultFetcher: VovkClientFetcher<_DefaultFetcherOptions>;

package/client/defaultFetcher.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._defaultFetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultFetcher';
+// defaultFetcher uses HttpException class to throw errors of fake HTTP status 0 if client-side error occurs
+// For normal HTTP errors, it uses message and status code from the response of ErrorResponseBody type
+const _defaultFetcher = async ({ httpMethod, getPath, validate }, { params, query, body, prefix = '', ...options }) => {
+    const endpoint = (prefix.startsWith('http://') || prefix.startsWith('https://') || prefix.startsWith('/') ? '' : '/') +
+        (prefix.endsWith('/') ? prefix : `${prefix}/`) +
+        getPath(params, query);
+    try {
+        validate({ body, query });
+    }
+    catch (e) {
+        // if HttpException is thrown, rethrow it
+        if (e instanceof HttpException_1._HttpException)
+            throw e;
+        // otherwise, throw HttpException with status 0
+        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    const init = {
+        method: httpMethod,
+        ...options,
+    };
+    if (body instanceof FormData) {
+        init.body = body;
+    }
+    else if (body) {
+        init.body = JSON.stringify(body);
+    }
+    let result;
+    let response;
+    try {
+        response = await fetch(endpoint, init);
+    }
+    catch (e) {
+        // handle network errors
+        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    try {
+        result = await response.json();
+    }
+    catch (e) {
+        // handle parsing errors
+        throw new HttpException_1._HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.ok) {
+        // handle server errors
+        throw new HttpException_1._HttpException(response.status, result?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    return result;
+};
+exports._defaultFetcher = _defaultFetcher;

package/client/defaultStreamFetcher.d.ts

@@ -0,0 +1,4 @@
+import type { _DefaultFetcherOptions as DefaultFetcherOptions } from './defaultFetcher';
+import type { _VovkClientFetcher as VovkClientFetcher } from './types';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultStreamFetcher";
+export declare const _defaultStreamFetcher: VovkClientFetcher<DefaultFetcherOptions>;

package/client/defaultStreamFetcher.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._defaultStreamFetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+const StreamResponse_1 = require("../StreamResponse");
+exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamFetcher';
+const _defaultStreamFetcher = async ({ httpMethod, getPath, validate }, { params, query, body, prefix = '', ...options }) => {
+    const endpoint = (prefix.startsWith('http://') || prefix.startsWith('https://') || prefix.startsWith('/') ? '' : '/') +
+        (prefix.endsWith('/') ? prefix : `${prefix}/`) +
+        getPath(params, query);
+    try {
+        validate({ body, query });
+    }
+    catch (e) {
+        // if HttpException is thrown, rethrow it
+        if (e instanceof HttpException_1._HttpException)
+            throw e;
+        // otherwise, throw HttpException with status 0
+        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    const init = {
+        method: httpMethod,
+        ...options,
+    };
+    if (body instanceof FormData) {
+        init.body = body;
+    }
+    else if (body) {
+        init.body = JSON.stringify(body);
+    }
+    let response;
+    try {
+        response = await fetch(endpoint, init);
+    }
+    catch (e) {
+        // handle network errors
+        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.ok) {
+        let result;
+        try {
+            result = await response.json();
+        }
+        catch {
+            // ignore parsing errors
+        }
+        // handle server errors
+        throw new HttpException_1._HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.body)
+        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
+    const reader = response.body.getReader();
+    async function* iterator() {
+        let prepend = '';
+        // Remove the Promise wrapper, as we will use async generator
+        while (true) {
+            let value;
+            let done = false;
+            try {
+                ({ value, done } = await reader.read());
+            }
+            catch (error) {
+                await reader.cancel();
+                throw new Error('Stream error. ' + String(error));
+            }
+            if (done) {
+                return;
+            }
+            const string = new TextDecoder().decode(value);
+            const lines = (prepend + string).split(StreamResponse_1._StreamResponse.JSON_DIVIDER).filter(Boolean);
+            for (const line of lines) {
+                let data;
+                try {
+                    data = JSON.parse(line);
+                    prepend = '';
+                }
+                catch (error) {
+                    prepend += string;
+                    break;
+                }
+                if (data) {
+                    if ('isError' in data && 'reason' in data) {
+                        const upcomingError = data.reason;
+                        await reader.cancel();
+                        if (typeof upcomingError === 'string') {
+                            throw new Error(upcomingError);
+                        }
+                        throw upcomingError;
+                    }
+                    else {
+                        yield data;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        [Symbol.asyncIterator]: iterator,
+        cancel: () => reader.cancel(),
+    };
+};
+exports._defaultStreamFetcher = _defaultStreamFetcher;

package/client/index.d.ts

@@ -0,0 +1,5 @@
+import { _clientizeController as clientizeController } from './clientizeController';
+import type { _VovkClientFetcher as VovkClientFetcher, _VovkClientOptions as VovkClientOptions } from './types';
+import { type _DefaultFetcherOptions as DefaultFetcherOptions, _defaultFetcher as defaultFetcher } from './defaultFetcher';
+export { clientizeController, defaultFetcher };
+export type { VovkClientFetcher, VovkClientOptions, DefaultFetcherOptions };

package/client/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFetcher = exports.clientizeController = void 0;
+const clientizeController_1 = require("./clientizeController");
+Object.defineProperty(exports, "clientizeController", { enumerable: true, get: function () { return clientizeController_1._clientizeController; } });
+const defaultFetcher_1 = require("./defaultFetcher");
+Object.defineProperty(exports, "defaultFetcher", { enumerable: true, get: function () { return defaultFetcher_1._defaultFetcher; } });

package/client/types.d.ts

@@ -0,0 +1,69 @@
+import type { _KnownAny as KnownAny, _HttpMethod as HttpMethod, _ControllerStaticMethod, _VovkBody, _VovkQuery, _VovkParams } from '../types';
+import { _StreamResponse as StreamResponse } from '../StreamResponse';
+export type _StaticMethodInput<T extends _ControllerStaticMethod> = (_VovkBody<T> extends undefined | void ? {
+    body?: undefined;
+} : _VovkBody<T> extends null ? {
+    body?: null;
+} : {
+    body: _VovkBody<T>;
+}) & (_VovkQuery<T> extends undefined | void ? {
+    query?: undefined;
+} : {
+    query: _VovkQuery<T>;
+}) & (_VovkParams<T> extends undefined | void ? {
+    params?: undefined;
+} : {
+    params: _VovkParams<T>;
+});
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+export type _StreamAsyncIterator<T> = {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    cancel: () => Promise<void> | void;
+};
+type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamResponse<STREAM> | Promise<StreamResponse<STREAM>>, OPTS extends Record<string, KnownAny>, STREAM extends KnownAny = unknown> = <R>(options: (_StaticMethodInput<T> extends {
+    body?: undefined | null;
+    query?: undefined;
+    params?: undefined;
+} ? unknown : Parameters<T>[0] extends void ? _StaticMethodInput<T>['params'] extends object ? {
+    params: _StaticMethodInput<T>['params'];
+} : unknown : _StaticMethodInput<T>) & (Partial<OPTS> | void)) => ReturnType<T> extends Promise<StreamResponse<infer U>> | StreamResponse<infer U> ? Promise<_StreamAsyncIterator<U>> : R extends object ? Promise<R> : ToPromise<ReturnType<T>>;
+export type _VovkClient<T, OPTS extends {
+    [key: string]: KnownAny;
+}> = {
+    [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> : never;
+};
+export type _VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (options: {
+    name: keyof T;
+    httpMethod: HttpMethod;
+    getPath: (params: {
+        [key: string]: string;
+    }, query: {
+        [key: string]: string;
+    }) => string;
+    validate: (input: {
+        body?: unknown;
+        query?: unknown;
+    }) => void;
+}, input: {
+    body: unknown;
+    query: {
+        [key: string]: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+} & OPTS) => KnownAny;
+export type _VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
+    disableClientValidation?: boolean;
+    fetcher?: _VovkClientFetcher<OPTS>;
+    streamFetcher?: _VovkClientFetcher<OPTS> | null;
+    validateOnClient?: (input: {
+        body?: unknown;
+        query?: unknown;
+    }, validators: {
+        body?: unknown;
+        query?: unknown;
+    }) => unknown;
+    defaultOptions?: Partial<OPTS>;
+};
+export {};

package/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/createDecorator.d.ts

@@ -0,0 +1,9 @@
+import type { _KnownAny as KnownAny, _VovkController as VovkController, _VovkRequest as VovkRequest } from './types';
+type Next = () => Promise<unknown>;
+export declare function _createDecorator<ARGS extends unknown[], REQUEST = VovkRequest<unknown>>(handler: (this: VovkController, req: REQUEST, next: Next, ...args: ARGS) => unknown, initHandler?: (this: VovkController, ...args: ARGS) => {
+    clientValidators?: {
+        body?: KnownAny;
+        query?: KnownAny;
+    };
+} | null | undefined): (...args: ARGS) => (target: KnownAny, propertyKey: string) => void;
+export {};

package/createDecorator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._createDecorator = void 0;
+function _createDecorator(handler, initHandler) {
+    return function decoratorCreator(...args) {
+        return function decorator(target, propertyKey) {
+            const controller = target;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const originalMethod = controller[propertyKey];
+            if (typeof originalMethod === 'function') {
+                const initResult = initHandler?.call(controller, ...args);
+                if (initResult?.clientValidators) {
+                    controller._handlers = {
+                        ...controller._handlers,
+                        [propertyKey]: {
+                            ...controller._handlers?.[propertyKey],
+                            clientValidators: initResult.clientValidators,
+                        },
+                    };
+                    initResult.clientValidators;
+                }
+                const method = function method(req, params) {
+                    const next = async () => {
+                        return (await originalMethod.call(controller, req, params));
+                    };
+                    return handler.call(controller, req, next, ...args);
+                };
+                // method._name = (originalMethod as { _name?: string })._name ?? originalMethod.name;
+                method._controller = controller;
+                // TODO define internal method type
+                originalMethod._controller = controller;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                controller[propertyKey] = method;
+            }
+            else {
+                throw new Error(`Unable to decorate: ${propertyKey} is not a function`);
+            }
+        };
+    };
+}
+exports._createDecorator = _createDecorator;