npm - vovk - Versions diffs - 3.4.1 → 3.5.1 - Mend

vovk 3.4.1 → 3.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/dist/HttpException.d.ts +7 -0
package/dist/HttpException.js +15 -0
package/dist/JSONLinesResponse.d.ts +14 -0
package/dist/JSONLinesResponse.js +59 -0
package/dist/VovkApp.d.ts +29 -0
package/dist/VovkApp.js +189 -0
package/dist/client/index.d.ts +3 -0
package/dist/client/index.js +7 -0
package/dist/client/types.d.ts +102 -0
package/dist/client/types.js +2 -0
package/dist/createDecorator.d.ts +6 -0
package/dist/createDecorator.js +43 -0
package/dist/createVovkApp.d.ts +62 -0
package/dist/createVovkApp.js +129 -0
package/dist/openapi/openAPIToVovkSchema/index.d.ts +1 -1
package/dist/openapi/openAPIToVovkSchema/index.js +29 -4
package/dist/openapi/openAPIToVovkSchema/pruneComponentsSchemas.d.ts +7 -0
package/dist/openapi/openAPIToVovkSchema/pruneComponentsSchemas.js +51 -0
package/dist/tsconfig.tsbuildinfo +1 -1
package/dist/types/config.d.ts +11 -0
package/dist/types.d.ts +239 -0
package/dist/types.js +66 -0
package/dist/utils/generateStaticAPI.d.ts +4 -0
package/dist/utils/generateStaticAPI.js +30 -0
package/dist/utils/getSchema.d.ts +20 -0
package/dist/utils/getSchema.js +33 -0
package/dist/utils/parseQuery.d.ts +25 -0
package/dist/utils/parseQuery.js +156 -0
package/dist/utils/reqForm.d.ts +2 -0
package/dist/utils/reqForm.js +32 -0
package/dist/utils/reqMeta.d.ts +2 -0
package/dist/utils/reqMeta.js +13 -0
package/dist/utils/reqQuery.d.ts +2 -0
package/dist/utils/reqQuery.js +10 -0
package/dist/utils/serializeQuery.d.ts +13 -0
package/dist/utils/serializeQuery.js +65 -0
package/dist/utils/setHandlerSchema.d.ts +4 -0
package/dist/utils/setHandlerSchema.js +15 -0
package/dist/utils/withValidation.d.ts +21 -0
package/dist/utils/withValidation.js +88 -0
package/package.json +1 -1
package/dist/core/compose.d.ts +0 -38
package/dist/core/compose.js +0 -31

package/dist/types/config.d.ts CHANGED Viewed

@@ -88,6 +88,17 @@ export interface VovkOpenAPIMixin {
     apiRoot?: string;
     getModuleName?: 'nestjs-operation-id' | (string & {}) | 'api' | GetOpenAPINameFn;
     getMethodName?: 'nestjs-operation-id' | 'camel-case-operation-id' | 'auto' | GetOpenAPINameFn;
+    /**
+     * Keep only operations the predicate returns `true` for; omitted = keep all. Runs before
+     * `getModuleName`/`getMethodName`, so a module whose operations are all filtered out is never created.
+     */
+    filterOperations?: (config: Parameters<GetOpenAPINameFn>[0]) => boolean;
+    /**
+     * Prune `meta.openAPIObject.components.schemas` to the transitive `$ref` closure of the kept operations,
+     * shrinking the generated schema for large specs. Removes `Mixins.<Segment>.<Component>` types for
+     * components nothing kept references — keep `false` (default) if you import such types directly.
+     */
+    pruneComponents?: boolean;
     errorMessageKey?: string;
     mixinName?: string;
 }

package/dist/types.d.ts ADDED Viewed

@@ -0,0 +1,239 @@
+import type { NextRequest } from 'next/server';
+import type { OperationObject } from 'openapi3-ts/oas31';
+import type { JSONLinesResponse } from './JSONLinesResponse';
+import { VovkStreamAsyncIterable } from './client/types';
+import type { PackageJson } from 'type-fest';
+export type KnownAny = any;
+export type StaticClass = Function;
+export type VovkHandlerSchema = {
+    path: string;
+    httpMethod: string;
+    validation?: {
+        query?: KnownAny;
+        body?: KnownAny;
+        params?: KnownAny;
+        output?: KnownAny;
+        iteration?: KnownAny;
+    };
+    openapi?: OperationObject;
+    misc?: Record<string, KnownAny>;
+};
+export type VovkControllerSchema = {
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix?: string;
+    handlers: Record<string, VovkHandlerSchema>;
+};
+export type VovkSegmentSchema = {
+    emitSchema: boolean;
+    segmentName: string;
+    controllers: Record<string, VovkControllerSchema>;
+};
+export type VovkErrorResponse = {
+    cause?: unknown;
+    statusCode: HttpStatus;
+    message: string;
+    isError: true;
+};
+export type VovkControllerInternal = {
+    _rpcModuleName?: VovkControllerSchema['rpcModuleName'];
+    _prefix?: VovkControllerSchema['prefix'];
+    _handlers: VovkControllerSchema['handlers'];
+    _handlersMetadata?: Record<string, {
+        staticParams?: Record<string, string>[];
+    }>;
+    _activated?: true;
+    _onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+};
+export type VovkController = StaticClass & VovkControllerInternal & {
+    [key: string]: unknown;
+};
+export type DecoratorOptions = {
+    cors?: boolean;
+    headers?: Record<string, string>;
+    staticParams?: Record<string, string>[];
+    before?: (this: VovkController, req: VovkRequest) => unknown;
+};
+export type RouteHandler = ((req: VovkRequest, params: Record<string, string>) => Response | Promise<Response> | Iterable<unknown> | AsyncIterable<unknown>) & {
+    _options?: DecoratorOptions;
+};
+export interface VovkRequest<BODY extends KnownAny = null, QUERY extends KnownAny = undefined, PARAMS extends KnownAny = undefined> extends Omit<NextRequest, 'json' | 'nextUrl'> {
+    json: () => Promise<BODY>;
+    nextUrl: Omit<NextRequest['nextUrl'], 'searchParams'> & {
+        searchParams: Omit<NextRequest['nextUrl']['searchParams'], 'get' | 'getAll' | 'entries' | 'forEach' | 'keys' | 'values'> & {
+            get: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends readonly (infer ITEM)[] ? ITEM : QUERY[KEY];
+            getAll: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends KnownAny[] ? QUERY[KEY] : QUERY[KEY][];
+            entries: () => IterableIterator<[keyof QUERY, QUERY[keyof QUERY]]>;
+            forEach: (callbackfn: (value: QUERY[keyof QUERY], key: keyof QUERY, searchParams: NextRequest['nextUrl']['searchParams']) => void) => void;
+            keys: () => IterableIterator<keyof QUERY>;
+            values: () => IterableIterator<QUERY[keyof QUERY]>;
+        };
+    };
+    vovk: {
+        body: () => Promise<BODY>;
+        query: () => QUERY;
+        meta: <T = Record<KnownAny, KnownAny>>(meta?: T | null) => T;
+        form: <T = KnownAny>() => Promise<T>;
+        params: () => PARAMS;
+    };
+}
+export type ControllerStaticMethod<REQ extends VovkRequest<KnownAny, KnownAny> = VovkRequest<undefined, Record<string, KnownAny>>, PARAMS extends {
+    [key: string]: string;
+} = KnownAny> = ((req: REQ, params: PARAMS) => unknown) & {
+    _controller?: VovkController;
+};
+export type VovkControllerBody<T extends (...args: KnownAny) => KnownAny> = Awaited<ReturnType<Parameters<T>[0]['vovk']['body']>>;
+export type VovkControllerQuery<T extends (...args: KnownAny) => KnownAny> = ReturnType<Parameters<T>[0]['vovk']['query']>;
+export type VovkControllerParams<T extends (...args: KnownAny) => KnownAny> = Parameters<T>[1] extends object ? Parameters<T>[1] : ReturnType<Parameters<T>[0]['vovk']['params']>;
+export type VovkControllerYieldType<T extends (req: VovkRequest<KnownAny, KnownAny>) => KnownAny> = T extends (...args: KnownAny[]) => AsyncGenerator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Generator<infer Y, KnownAny, KnownAny> ? Y : T extends (...args: KnownAny[]) => Promise<JSONLinesResponse<infer Y>> | JSONLinesResponse<infer Y> ? Y : never;
+export type VovkControllerOutput<T extends ((...args: KnownAny) => KnownAny) & {
+    __output?: KnownAny;
+}> = T['__output'];
+export type VovkControllerIteration<T extends ((...args: KnownAny) => KnownAny) & {
+    __iteration?: KnownAny;
+}> = T['__iteration'];
+export type VovkBody<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['body'];
+export type VovkQuery<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['query'];
+export type VovkParams<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['params'];
+export type VovkYieldType<T extends (...args: KnownAny[]) => unknown> = T extends (...args: KnownAny[]) => Promise<VovkStreamAsyncIterable<infer Y>> ? Y : never;
+export type VovkReturnType<T extends (...args: KnownAny) => unknown> = Awaited<ReturnType<T>>;
+export type StreamAbortMessage = {
+    isError: true;
+    reason: KnownAny;
+};
+export type VovkValidationType = 'body' | 'query' | 'params' | 'output' | 'iteration';
+export type VovkFullSchema = {
+    config: Partial<VovkStrictConfig>;
+    segments: Record<string, VovkSegmentSchema>;
+};
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export declare enum HttpStatus {
+    NULL = 0,
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}
+type ClientConfigCommon = {
+    enabled?: boolean;
+    outDir?: string;
+    fromTemplates?: string[];
+} & ({
+    excludeSegments?: never;
+    includeSegments?: string[];
+} | {
+    excludeSegments?: string[];
+    includeSegments?: never;
+});
+type ClientConfigFull = ClientConfigCommon & {
+    package?: PackageJson;
+};
+type ClientConfigSegmented = ClientConfigCommon & {
+    packages?: Record<string, PackageJson>;
+};
+export type ClientTemplateDef = {
+    extends?: string;
+    templatePath?: string | null;
+    origin?: string | null;
+    fullClient?: Omit<ClientConfigFull, 'fromTemplates' | 'enabled'>;
+    segmentedClient?: Omit<ClientConfigSegmented, 'fromTemplates' | 'enabled'>;
+    segmentConfig?: false | Record<string, {
+        origin?: string;
+        rootEntry?: boolean;
+    }>;
+    requires?: Record<string, string>;
+};
+export type VovkConfig = {
+    emitConfig?: boolean | (keyof VovkStrictConfig)[];
+    schemaOutDir?: string;
+    fullClient?: ClientConfigFull;
+    segmentedClient?: ClientConfigSegmented;
+    imports?: {
+        fetcher?: string | [string, string] | [string];
+        validateOnClient?: string | [string, string] | [string];
+        createRPC?: string | [string, string] | [string];
+    };
+    modulesDir?: string;
+    rootEntry?: string;
+    origin?: string;
+    rootSegmentModulesDirName?: string;
+    logLevel?: 'error' | 'trace' | 'debug' | 'info' | 'warn';
+    prettifyClient?: boolean;
+    devHttps?: boolean;
+    clientTemplateDefs?: Record<string, ClientTemplateDef>;
+    moduleTemplates?: {
+        service?: string;
+        controller?: string;
+        [key: string]: string | undefined;
+    };
+    libs?: Record<string, KnownAny>;
+    segmentConfig?: false | Record<string, {
+        origin?: string;
+        rootEntry?: boolean;
+    }>;
+};
+export type VovkStrictConfig = Required<Omit<VovkConfig, 'emitConfig' | 'libs' | 'imports' | 'fullClient' | 'segmentedClient'>> & {
+    emitConfig: (keyof VovkStrictConfig)[];
+    imports: {
+        fetcher: [string, string] | [string];
+        validateOnClient: [string, string] | [string] | null;
+        createRPC: [string, string] | [string];
+    };
+    libs: Record<string, KnownAny>;
+    fullClient: RequireFields<ClientConfigFull, 'enabled' | 'fromTemplates' | 'outDir'>;
+    segmentedClient: RequireFields<ClientConfigSegmented, 'enabled' | 'fromTemplates' | 'outDir'>;
+};
+type RequireFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export {};

package/dist/types.js ADDED Viewed

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStatus = exports.HttpMethod = void 0;
+// Enums
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["NULL"] = 0] = "NULL";
+    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatus[HttpStatus["MISDIRECTED"] = 421] = "MISDIRECTED";
+    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+})(HttpStatus || (exports.HttpStatus = HttpStatus = {}));

package/dist/utils/generateStaticAPI.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import type { StaticClass } from '../types';
+export declare function generateStaticAPI(c: Record<string, StaticClass>, slug?: string): {
+    [slug]: string[];
+}[];

package/dist/utils/generateStaticAPI.js ADDED Viewed

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStaticAPI = generateStaticAPI;
+function generateStaticAPI(c, slug = 'vovk') {
+    const controllers = c;
+    return [
+        { [slug]: ['_schema_'] },
+        ...Object.values(controllers)
+            .map((controller) => {
+            const handlers = controller._handlers;
+            const splitPrefix = controller._prefix?.split('/') ?? [];
+            return Object.entries(handlers)
+                .map(([name, handler]) => {
+                const staticParams = controller._handlersMetadata?.[name]?.staticParams;
+                if (staticParams?.length) {
+                    return staticParams.map((paramsItem) => {
+                        let path = handler.path;
+                        for (const [key, value] of Object.entries(paramsItem)) {
+                            path = path.replace(`:${key}`, value);
+                        }
+                        return { [slug]: [...splitPrefix, ...path.split('/')].filter(Boolean) };
+                    });
+                }
+                return [{ [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) }];
+            })
+                .flat();
+        })
+            .flat(),
+    ];
+}

package/dist/utils/getSchema.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { VovkSegmentSchema, VovkController, StaticClass } from '../types';
+export declare function getControllerSchema(controller: VovkController, rpcModuleName: string, exposeValidation: boolean): {
+    rpcModuleName: string;
+    originalControllerName: string;
+    prefix: string;
+    handlers: {
+        [k: string]: {
+            path: string;
+            httpMethod: string;
+            openapi?: import("openapi3-ts/oas31").OperationObject;
+            misc?: Record<string, import("../types").KnownAny>;
+        };
+    };
+};
+export default function getSchema(options: {
+    emitSchema?: boolean;
+    segmentName?: string;
+    controllers: Record<string, StaticClass>;
+    exposeValidation?: boolean;
+}): VovkSegmentSchema;

package/dist/utils/getSchema.js ADDED Viewed

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllerSchema = getControllerSchema;
+exports.default = getSchema;
+function getControllerSchema(controller, rpcModuleName, exposeValidation) {
+    return {
+        rpcModuleName,
+        originalControllerName: controller.name,
+        prefix: controller._prefix ?? '',
+        handlers: {
+            ...(exposeValidation
+                ? controller._handlers
+                : Object.fromEntries(
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                Object.entries(controller._handlers ?? {}).map(([key, { validation: _v, ...value }]) => [key, value]))),
+        },
+    };
+}
+function getSchema(options) {
+    const exposeValidation = options?.exposeValidation ?? true;
+    const emitSchema = options.emitSchema ?? true;
+    const schema = {
+        emitSchema,
+        segmentName: options.segmentName ?? '',
+        controllers: {},
+    };
+    if (!emitSchema)
+        return schema;
+    for (const [rpcModuleName, controller] of Object.entries(options.controllers)) {
+        schema.controllers[rpcModuleName] = getControllerSchema(controller, rpcModuleName, exposeValidation);
+    }
+    return schema;
+}

package/dist/utils/parseQuery.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { KnownAny } from '../types';
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+export default function parseQuery(queryString: string): Record<string, KnownAny>;

package/dist/utils/parseQuery.js ADDED Viewed

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseQuery;
+/**
+ * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
+ * into an array of path segments (strings or special push-markers).
+ *
+ * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
+ * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
+ */
+function parseKey(key) {
+    // The first segment is everything up to the first '[' (or the entire key if no '[')
+    const segments = [];
+    const topKeyMatch = key.match(/^([^[\]]+)/);
+    if (topKeyMatch) {
+        segments.push(topKeyMatch[1]);
+    }
+    else {
+        // If it starts with brackets, treat it as empty? (edge case)
+        segments.push('');
+    }
+    // Now capture all bracket parts: [something], [0], []
+    const bracketRegex = /\[([^[\]]*)\]/g;
+    let match;
+    while ((match = bracketRegex.exec(key)) !== null) {
+        // match[1] is the content inside the brackets
+        segments.push(match[1]);
+    }
+    return segments;
+}
+/**
+ * Recursively set a value in a nested object/array, given a path of segments.
+ * - If segment is numeric => treat as array index
+ * - If segment is empty "" => push to array
+ * - Else => object property
+ */
+function setValue(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        // If we're at the last segment, set the value
+        if (i === path.length - 1) {
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current.push(value);
+            }
+            else if (!isNaN(Number(segment))) {
+                // Numeric segment => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                current[idx] = value;
+            }
+            else {
+                // Object property
+                current[segment] = value;
+            }
+        }
+        else {
+            // Not the last segment: descend into existing structure or create it
+            const nextSegment = path[i + 1];
+            if (segment === '') {
+                // Empty bracket => push
+                if (!Array.isArray(current)) {
+                    // Convert the current node into an array, if not one
+                    current = [];
+                }
+                // If we are not at the last path, we need a placeholder object or array
+                // for the next segment. We'll push something and move current to that.
+                if (current.length === 0) {
+                    // nothing in array yet
+                    current.push(typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {});
+                }
+                else if (typeof nextSegment === 'string' && !isNaN(Number(nextSegment))) {
+                    // next is numeric => we want an array
+                    if (!Array.isArray(current[current.length - 1])) {
+                        current[current.length - 1] = [];
+                    }
+                }
+                else {
+                    // next is not numeric => we want an object
+                    if (typeof current[current.length - 1] !== 'object') {
+                        current[current.length - 1] = {};
+                    }
+                }
+                current = current[current.length - 1];
+            }
+            else if (!isNaN(Number(segment))) {
+                // segment is numeric => array index
+                const idx = Number(segment);
+                if (!Array.isArray(current)) {
+                    current = [];
+                }
+                if (current[idx] === undefined) {
+                    // Create placeholder for next segment
+                    current[idx] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[idx];
+            }
+            else {
+                // segment is an object key
+                if (current[segment] === undefined) {
+                    // Create placeholder
+                    current[segment] = typeof nextSegment === 'string' && !isNaN(Number(nextSegment)) ? [] : {};
+                }
+                current = current[segment];
+            }
+        }
+    }
+}
+/**
+ * Deserialize a bracket-based query string into an object.
+ *
+ * Supports:
+ *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
+ *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
+ *   - Mixed arrays of objects, etc.
+ *
+ * @example
+ *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
+ *   => {
+ *        x: "xx",
+ *        y: ["yy", "uu"],
+ *        z: {
+ *          f: "x",
+ *          u: ["uu", "xx"],
+ *          d: { x: "ee" }
+ *        }
+ *      }
+ *
+ * @param queryString - The raw query string (e.g. location.search.slice(1))
+ * @returns           - A nested object representing the query params
+ */
+function parseQuery(queryString) {
+    const result = {};
+    if (!queryString)
+        return result;
+    // Split into key=value pairs
+    const pairs = queryString
+        .replace(/^\?/, '') // Remove leading "?" if present
+        .split('&');
+    for (const pair of pairs) {
+        const [rawKey, rawVal = ''] = pair.split('=');
+        const decodedKey = decodeURIComponent(rawKey || '');
+        const decodedVal = decodeURIComponent(rawVal);
+        // Parse bracket notation
+        const pathSegments = parseKey(decodedKey);
+        // Insert into the result object
+        setValue(result, pathSegments, decodedVal);
+    }
+    return result;
+}

package/dist/utils/reqForm.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { KnownAny, VovkRequest } from '../types';
2	+ export default function reqForm<T = KnownAny>(req: VovkRequest<KnownAny, KnownAny>): Promise<T>;

package/dist/utils/reqForm.js ADDED Viewed

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqForm;
+const formMap = new WeakMap();
+async function reqForm(req) {
+    if (formMap.has(req)) {
+        return formMap.get(req);
+    }
+    const body = await req.formData();
+    const formData = {};
+    for (const [key, value] of body.entries()) {
+        if (value instanceof File) {
+            // If this key already exists, convert to array or append to existing array
+            if (formData[key]) {
+                if (Array.isArray(formData[key])) {
+                    formData[key].push(value);
+                }
+                else {
+                    formData[key] = [formData[key], value];
+                }
+            }
+            else {
+                formData[key] = value;
+            }
+        }
+        else {
+            formData[key] = value.toString();
+        }
+    }
+    formMap.set(req, formData);
+    return formData;
+}

package/dist/utils/reqMeta.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { KnownAny, VovkRequest } from '../types';
2	+ export default function reqMeta<T = Record<KnownAny, KnownAny>>(req: VovkRequest<KnownAny, KnownAny>, meta?: T \| null): T;

package/dist/utils/reqMeta.js ADDED Viewed

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqMeta;
+const metaMap = new WeakMap();
+function reqMeta(req, meta) {
+    if (meta) {
+        metaMap.set(req, { ...metaMap.get(req), ...meta });
+    }
+    else if (meta === null) {
+        metaMap.delete(req);
+    }
+    return (metaMap.get(req) ?? {});
+}

package/dist/utils/reqQuery.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { KnownAny, VovkRequest } from '../types';
2	+ export default function reqQuery<T extends object \| undefined>(req: VovkRequest<KnownAny, T>): T;

package/dist/utils/reqQuery.js ADDED Viewed

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reqQuery;
+const parseQuery_1 = __importDefault(require("./parseQuery"));
+function reqQuery(req) {
+    return (0, parseQuery_1.default)(req.nextUrl.search);
+}