vovk 3.4.1 → 3.5.1

package/dist/utils/serializeQuery.d.ts

@@ -0,0 +1,13 @@
+import type { KnownAny } from '../types';
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+export default function serializeQuery(obj: Record<string, KnownAny>): string;

package/dist/utils/serializeQuery.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serializeQuery;
+/**
+ * Recursively build query parameters from an object.
+ *
+ * @param key      - The query key so far (e.g. 'user', 'user[0]', 'user[0][name]')
+ * @param value    - The current value to serialize
+ * @returns        - An array of `key=value` strings
+ */
+function buildParams(key, value) {
+    if (value === null || value === undefined) {
+        return []; // skip null/undefined values entirely
+    }
+    // If value is an object or array, we need to recurse
+    if (typeof value === 'object') {
+        // Array case
+        if (Array.isArray(value)) {
+            /**
+             * We use index-based bracket notation here:
+             *   e.g. for value = ['aa', 'bb'] and key = 'foo'
+             *   => "foo[0]=aa&foo[1]=bb"
+             *
+             * If you prefer "foo[]=aa&foo[]=bb" style, replace:
+             *   `${key}[${i}]`
+             * with:
+             *   `${key}[]`
+             */
+            return value.flatMap((v, i) => {
+                const newKey = `${key}[${i}]`;
+                return buildParams(newKey, v);
+            });
+        }
+        // Plain object case
+        return Object.keys(value).flatMap((k) => {
+            const newKey = `${key}[${k}]`;
+            return buildParams(newKey, value[k]);
+        });
+    }
+    return [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`];
+}
+/**
+ * Serialize a nested object (including arrays, arrays of objects, etc.)
+ * into a bracket-based query string.
+ *
+ * @example
+ *   serializeQuery({ x: 'xx', y: [1, 2], z: { f: 'x' } })
+ *   => "x=xx&y[0]=1&y[1]=2&z[f]=x"
+ *
+ * @param obj - The input object to be serialized
+ * @returns   - A bracket-based query string (without leading "?")
+ */
+function serializeQuery(obj) {
+    if (!obj || typeof obj !== 'object')
+        return '';
+    // Collect query segments
+    const segments = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            segments.push(...buildParams(key, value));
+        }
+    }
+    return segments.join('&');
+}

package/dist/utils/setHandlerSchema.d.ts

@@ -0,0 +1,4 @@
+import type { KnownAny, VovkController, VovkHandlerSchema } from '../types';
+export declare function setHandlerSchema(h: ((...args: KnownAny[]) => KnownAny) & {
+    _getSchema?: (controller: VovkController) => Omit<VovkHandlerSchema, 'httpMethod' | 'path'>;
+}, schema: Omit<VovkHandlerSchema, 'httpMethod' | 'path'>): Promise<void>;

package/dist/utils/setHandlerSchema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHandlerSchema = setHandlerSchema;
+async function setHandlerSchema(h, schema) {
+    h._getSchema = (controller) => {
+        if (!controller) {
+            throw new Error('Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?');
+        }
+        const handlerName = Object.getOwnPropertyNames(controller).find((key) => controller[key]._sourceMethod === h);
+        if (!handlerName) {
+            throw new Error('Error setting client validators. Handler not found.');
+        }
+        return schema;
+    };
+}

package/dist/utils/withValidation.d.ts

@@ -0,0 +1,21 @@
+import { VovkValidationType, type KnownAny, type VovkRequest } from '../types';
+export declare function withValidation<T extends (req: KnownAny, params: KnownAny) => KnownAny, BODY_MODEL, QUERY_MODEL, PARAMS_MODEL, OUTPUT_MODEL, ITERATION_MODEL>({ disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, getJSONSchemaFromModel, validate, }: {
+    disableServerSideValidation?: boolean | VovkValidationType[];
+    skipSchemaEmission?: boolean | VovkValidationType[];
+    validateEachIteration?: boolean;
+    body?: BODY_MODEL;
+    query?: QUERY_MODEL;
+    params?: PARAMS_MODEL;
+    output?: OUTPUT_MODEL;
+    iteration?: ITERATION_MODEL;
+    handle: T;
+    getJSONSchemaFromModel?: (model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType;
+    }) => KnownAny;
+    validate: (data: KnownAny, model: NonNullable<BODY_MODEL | QUERY_MODEL | PARAMS_MODEL | OUTPUT_MODEL | ITERATION_MODEL>, meta: {
+        type: VovkValidationType;
+        req: VovkRequest<KnownAny, KnownAny>;
+        status?: number;
+        i?: number;
+    }) => KnownAny;
+}): T;

package/dist/utils/withValidation.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withValidation = withValidation;
+const HttpException_1 = require("../HttpException");
+const types_1 = require("../types");
+const setHandlerSchema_1 = require("./setHandlerSchema");
+const validationTypes = ['body', 'query', 'params', 'output', 'iteration'];
+function withValidation({ disableServerSideValidation, skipSchemaEmission, validateEachIteration, body, query, params, output, iteration, handle, getJSONSchemaFromModel, validate, }) {
+    const disableServerSideValidationKeys = disableServerSideValidation === false
+        ? []
+        : disableServerSideValidation === true
+            ? validationTypes
+            : (disableServerSideValidation ?? []);
+    const skipSchemaEmissionKeys = skipSchemaEmission === false ? [] : skipSchemaEmission === true ? validationTypes : (skipSchemaEmission ?? []);
+    const outputHandler = async (req, handlerParams) => {
+        const data = await handle(req, handlerParams);
+        if (output && iteration) {
+            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, "Output and iteration are mutually exclusive. You can't use them together.");
+        }
+        if (output && !disableServerSideValidationKeys.includes('output')) {
+            if (!data) {
+                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Output is required. You probably forgot to return something from your handler.');
+            }
+            await validate(data, output, { type: 'output', req });
+        }
+        if (iteration && !disableServerSideValidationKeys.includes('iteration')) {
+            // We assume `data` is an async iterable here; you might want to check that:
+            if (!data || typeof data[Symbol.asyncIterator] !== 'function') {
+                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, 'Data is not an async iterable but iteration validation is defined.');
+            }
+            // Return a brand-new async generator that yields validated items
+            return (async function* () {
+                let i = 0;
+                for await (const item of data) {
+                    if (validateEachIteration || i === 0) {
+                        await validate(item, iteration, { type: 'iteration', req, status: 200, i });
+                    }
+                    i++;
+                    yield item;
+                }
+            })();
+        }
+        else if (validateEachIteration) {
+            throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, 'validateEachIteration is set but iteration is not defined.');
+        }
+        return data;
+    };
+    const resultHandler = async (req, handlerParams) => {
+        if (body && !disableServerSideValidationKeys.includes('body')) {
+            const data = await req.json();
+            const instance = (await validate(data, body, { type: 'body', req })) ?? data;
+            // redeclare to add ability to call req.json() again
+            req.json = () => Promise.resolve(data);
+            req.vovk.body = () => Promise.resolve(instance);
+        }
+        if (query && !disableServerSideValidationKeys.includes('query')) {
+            const data = req.vovk.query();
+            const instance = (await validate(data, query, { type: 'query', req })) ?? data;
+            req.vovk.query = () => instance;
+        }
+        if (params && !disableServerSideValidationKeys.includes('params')) {
+            const data = req.vovk.params();
+            const instance = (await validate(data, params, { type: 'params', req })) ?? data;
+            req.vovk.params = () => instance;
+        }
+        return outputHandler(req, handlerParams);
+    };
+    if (getJSONSchemaFromModel) {
+        const validation = {};
+        if (body && !skipSchemaEmissionKeys.includes('body')) {
+            validation.body = getJSONSchemaFromModel(body, { type: 'body' });
+        }
+        if (query && !skipSchemaEmissionKeys.includes('query')) {
+            validation.query = getJSONSchemaFromModel(query, { type: 'query' });
+        }
+        if (params && !skipSchemaEmissionKeys.includes('params')) {
+            validation.params = getJSONSchemaFromModel(params, { type: 'params' });
+        }
+        if (output && !skipSchemaEmissionKeys.includes('output')) {
+            validation.output = getJSONSchemaFromModel(output, { type: 'output' });
+        }
+        if (iteration && !skipSchemaEmissionKeys.includes('iteration')) {
+            validation.iteration = getJSONSchemaFromModel(iteration, { type: 'iteration' });
+        }
+        (0, setHandlerSchema_1.setHandlerSchema)(resultHandler, { validation });
+    }
+    return resultHandler;
+}

package/package.json

@@ -7,7 +7,7 @@
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "version": "3.4.1",
+  "version": "3.5.1",
   "bin": {
     "vovk-cli-npx": "./bin/index.mjs"
   },

package/dist/core/compose.d.ts

@@ -1,38 +0,0 @@
-import type { KnownAny } from '../types/utils.js';
-/**
- * Metadata stored on a handler by HTTP decorators and custom decorators when used outside decorator context (via compose).
- */
-export type ComposeMetadata = {
-    httpMethod?: string;
-    path?: string;
-    options?: KnownAny;
-    decoratorAppliers?: ((controller: KnownAny, propertyKey: string) => void)[];
-};
-/**
- * Composes decorators and a handler/class into a single value.
- *
- * For method-level composition, decorators are stored and applied later by initSegment.
- * For class-level composition, decorators like prefix() and cloneControllerMetadata()
- * are applied immediately to the class in reverse order (matching stacked decorator semantics).
- *
- * @example Method-level
- * ```ts
- * static handleParams = compose(
- *   put('x/{foo}/{bar}/y'),
- *   authGuard(null),
- *   procedure({ params: z.object({ foo: z.string(), bar: z.string() }) })
- *     .handle(async (req) => req.vovk.params())
- * );
- * ```
- *
- * @example Class-level
- * ```ts
- * const MyController = compose(
- *   prefix('users'),
- *   cloneControllerMetadata(),
- *   class extends ParentController {}
- * );
- * export default MyController;
- * ```
- */
-export declare function compose<T>(...args: [...unknown[], T]): T;

package/dist/core/compose.js

@@ -1,31 +0,0 @@
-export function compose(...args) {
-    if (args.length === 0)
-        throw new Error('compose() requires at least one argument');
-    const last = args[args.length - 1];
-    const decoratorFns = args.slice(0, -1);
-    if (typeof last !== 'function') {
-        throw new Error('The last argument to compose() must be a function, handler, or class');
-    }
-    for (const decoratorFn of decoratorFns) {
-        if (typeof decoratorFn !== 'function') {
-            throw new Error('All arguments to compose() except the last must be decorator functions');
-        }
-    }
-    // Detect class: native ES class constructors' toString() starts with "class"
-    if (last.toString().startsWith('class ')) {
-        // Apply class decorators in reverse order (bottom-up, matching stacked decorator semantics).
-        // Decorators mutate and return the same class, so .name is preserved.
-        for (let i = decoratorFns.length - 1; i >= 0; i--) {
-            decoratorFns[i](last);
-        }
-        return last;
-    }
-    // Method-level compose: store decorator appliers for deferred execution by initSegment
-    const handler = last;
-    handler._composeMetadata = handler._composeMetadata ?? {};
-    handler._composeMetadata.decoratorAppliers = handler._composeMetadata.decoratorAppliers ?? [];
-    for (const decoratorFn of decoratorFns) {
-        handler._composeMetadata.decoratorAppliers.push(decoratorFn);
-    }
-    return handler;
-}