vovk 3.0.0-draft.46 → 3.0.0-draft.460

package/cjs/utils/createStandardValidation.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStandardValidation = createStandardValidation;
+const types_1 = require("../types");
+const withValidationLibrary_1 = require("./withValidationLibrary");
+const HttpException_1 = require("../HttpException");
+function createStandardValidation({ toJSONSchema, }) {
+    function withStandard({ isForm, body, query, params, output, iteration, handle, disableServerSideValidation, skipSchemaEmission, validateEachIteration, operationObject, }) {
+        return (0, withValidationLibrary_1.withValidationLibrary)({
+            isForm,
+            body,
+            query,
+            params,
+            output,
+            iteration,
+            disableServerSideValidation,
+            skipSchemaEmission,
+            validateEachIteration,
+            handle: handle,
+            toJSONSchema,
+            validate: async (data, model, { type, i }) => {
+                const result = await model['~standard'].validate(data);
+                if (result.issues?.length) {
+                    throw new HttpException_1.HttpException(types_1.HttpStatus.BAD_REQUEST, `Validation failed. Invalid ${type === 'iteration' ? `${type} #${i}` : type} on server: ${result.issues
+                        .map(({ message, path }) => `${message}${path ? ` at ${path.join('.')}` : ''}`)
+                        .join(', ')}`, { [type]: data, result });
+                }
+                return result.value;
+            },
+            operationObject,
+        });
+    }
+    return withStandard;
+}

package/cjs/utils/createValidateOnClient.d.ts

@@ -0,0 +1,7 @@
+import type { VovkValidateOnClient } from '../client';
+import type { KnownAny, VovkBasicJSONSchema } from '../types';
+export declare function createValidateOnClient<TFetcherOptions>({ validate, }: {
+    validate: (input: unknown, schema: VovkBasicJSONSchema, meta: Parameters<VovkValidateOnClient<TFetcherOptions>>[2] & {
+        type: 'body' | 'query' | 'params';
+    }) => KnownAny | Promise<KnownAny>;
+}): VovkValidateOnClient<TFetcherOptions>;

package/cjs/utils/createValidateOnClient.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidateOnClient = createValidateOnClient;
+function createValidateOnClient({ validate, }) {
+    const validateOnClient = async function validateOnClient(input, validation, meta) {
+        const newInput = { ...input };
+        if (input.body && validation.body) {
+            newInput.body = (await validate(input.body, validation.body, { ...meta, type: 'body' })) ?? input.body;
+        }
+        if (input.query && validation.query) {
+            newInput.query = (await validate(input.query, validation.query, { ...meta, type: 'query' })) ?? input.query;
+        }
+        if (input.params && validation.params) {
+            newInput.params = (await validate(input.params, validation.params, { ...meta, type: 'params' })) ?? input.params;
+        }
+        return newInput;
+    };
+    return validateOnClient;
+}

package/cjs/utils/deepExtend.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type SpecificValue = Buffer | Date | RegExp;
+declare function isSpecificValue(val: any): val is SpecificValue;
+declare function cloneSpecificValue(val: SpecificValue): SpecificValue;
+/**
+ * Recursive cloning array.
+ */
+declare function deepCloneArray<T = any>(arr: T[]): T[];
+declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): any;
+/**
+ * Extending object that entered in first argument.
+ *
+ * Returns extended object or false if have no target object or incorrect type.
+ *
+ * If you wish to clone source object (without modify it), just use empty new
+ * object as first argument, like this:
+ *   deepExtend({}, yourObj_1, [yourObj_N]);
+ */
+declare function deepExtend<T extends object>(...args: [T, ...Partial<T>[]]): T;
+declare function deepExtend<T extends object, U extends object>(target: T, source: U): T & U;
+declare function deepExtend<T extends object, U extends object, V extends object>(target: T, source1: U, source2: V): T & U & V;
+declare function deepExtend<T extends object, U extends object, V extends object, W extends object>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+declare function deepExtend<T extends object>(target: T, ...sources: any[]): T;
+export default deepExtend;
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
+export type { DeepPartial, SpecificValue };

package/cjs/utils/deepExtend.js

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepExtend = deepExtend;
+exports.deepCloneArray = deepCloneArray;
+exports.isSpecificValue = isSpecificValue;
+exports.cloneSpecificValue = cloneSpecificValue;
+exports.safeGetProperty = safeGetProperty;
+function isSpecificValue(val) {
+    return val instanceof Buffer || val instanceof Date || val instanceof RegExp;
+}
+function cloneSpecificValue(val) {
+    if (val instanceof Buffer) {
+        const x = Buffer.alloc ? Buffer.alloc(val.length) : Buffer.from(val);
+        val.copy(x);
+        return x;
+    }
+    else if (val instanceof Date) {
+        return new Date(val.getTime());
+    }
+    else if (val instanceof RegExp) {
+        return new RegExp(val);
+    }
+    else {
+        throw new Error('Unexpected situation');
+    }
+}
+/**
+ * Recursive cloning array.
+ */
+function deepCloneArray(arr) {
+    const clone = [];
+    arr.forEach((item, index) => {
+        if (typeof item === 'object' && item !== null) {
+            if (Array.isArray(item)) {
+                clone[index] = deepCloneArray(item);
+            }
+            else if (isSpecificValue(item)) {
+                clone[index] = cloneSpecificValue(item);
+            }
+            else {
+                clone[index] = deepExtend({}, item);
+            }
+        }
+        else {
+            clone[index] = item;
+        }
+    });
+    return clone;
+}
+function safeGetProperty(object, property) {
+    return property === '__proto__' ? undefined : object[property];
+}
+function deepExtend(...args) {
+    if (args.length < 1 || typeof args[0] !== 'object') {
+        return false;
+    }
+    if (args.length < 2) {
+        return args[0];
+    }
+    const target = args[0];
+    // convert arguments to array and cut off target object
+    const sources = args.slice(1);
+    sources.forEach((obj) => {
+        // skip argument if isn't an object, is null, or is an array
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            return;
+        }
+        Object.keys(obj).forEach((key) => {
+            const src = safeGetProperty(target, key); // source value
+            const val = safeGetProperty(obj, key); // new value
+            // recursion prevention
+            if (val === target) {
+                return;
+            }
+            else if (typeof val !== 'object' || val === null) {
+                /**
+                 * if new value isn't object then just overwrite by new value
+                 * instead of extending.
+                 */
+                target[key] = val;
+                return;
+            }
+            // just clone arrays (and recursive clone objects inside)
+            else if (Array.isArray(val)) {
+                target[key] = deepCloneArray(val);
+                return;
+            }
+            // custom cloning and overwrite for specific objects
+            else if (isSpecificValue(val)) {
+                target[key] = cloneSpecificValue(val);
+                return;
+            }
+            // overwrite by new value if source isn't object or array
+            else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+                target[key] = deepExtend({}, val);
+                return;
+            }
+            // source value and new value is objects both, extending...
+            else {
+                target[key] = deepExtend(src, val);
+                return;
+            }
+        });
+    });
+    return target;
+}
+exports.default = deepExtend;

package/{utils → cjs/utils}/generateStaticAPI.d.ts

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

package/cjs/utils/generateStaticAPI.js

@@ -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/cjs/utils/getJSONSchemaExample.d.ts

@@ -0,0 +1,11 @@
+import { KnownAny, VovkBasicJSONSchema } from '../types';
+interface SamplerOptions {
+    comment?: '//' | '#';
+    stripQuotes?: boolean;
+    indent?: number;
+    nestingIndent?: number;
+    ignoreBinary?: boolean;
+}
+export declare function getJSONSchemaExample(schema: VovkBasicJSONSchema, options: SamplerOptions, rootSchema?: VovkBasicJSONSchema): string;
+export declare function getSampleValue(schema: VovkBasicJSONSchema, rootSchema?: VovkBasicJSONSchema, ignoreBinary?: boolean): KnownAny;
+export {};

package/cjs/utils/getJSONSchemaExample.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSONSchemaExample = getJSONSchemaExample;
+exports.getSampleValue = getSampleValue;
+function getJSONSchemaExample(schema, options, rootSchema) {
+    const { comment = '//', stripQuotes = false, indent = 0, nestingIndent = 4, ignoreBinary = false } = options;
+    if (!schema || typeof schema !== 'object')
+        return 'null';
+    // Use the input schema as the root if not provided
+    rootSchema = rootSchema || schema;
+    // Get the sample value
+    const sampleValue = getSampleValue(schema, rootSchema, ignoreBinary);
+    // Format the output with descriptions
+    return formatWithDescriptions(sampleValue, schema, rootSchema, comment, stripQuotes, indent, nestingIndent, ignoreBinary, true // isTopLevel
+    );
+}
+function getSampleValue(schema, rootSchema, ignoreBinary) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    rootSchema = rootSchema || schema;
+    // Check if this is a binary string schema and should be ignored
+    if (ignoreBinary && schema.type === 'string' && schema.format === 'binary') {
+        return undefined;
+    }
+    // If there's an example, use it
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // If there are examples, use one of them
+    if (schema.examples && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Handle const if present
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    // Handle $ref if present
+    if (schema.$ref) {
+        return handleRef(schema.$ref, rootSchema, ignoreBinary);
+    }
+    // Handle enum if present
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle oneOf, anyOf, allOf
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return getSampleValue(schema.oneOf[0], rootSchema, ignoreBinary);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return getSampleValue(schema.anyOf[0], rootSchema, ignoreBinary);
+    }
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas in allOf
+        const mergedSchema = schema.allOf.reduce((acc, s) => ({ ...acc, ...s }), {});
+        return getSampleValue(mergedSchema, rootSchema, ignoreBinary);
+    }
+    // Handle different types
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return handleString(schema);
+            case 'number':
+            case 'integer':
+                return handleNumber(schema);
+            case 'boolean':
+                return handleBoolean();
+            case 'object':
+                return handleObject(schema, rootSchema, ignoreBinary);
+            case 'array':
+                return handleArray(schema, rootSchema, ignoreBinary);
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    // If type is not specified but properties are, treat it as an object
+    if (schema.properties) {
+        return handleObject(schema, rootSchema, ignoreBinary);
+    }
+    // Default fallback
+    return null;
+}
+function formatWithDescriptions(value, schema, rootSchema, comment, stripQuotes, indent, nestingIndent, ignoreBinary, isTopLevel) {
+    const indentStr = ' '.repeat(indent);
+    const nestIndentStr = ' '.repeat(nestingIndent); // Create nesting indent string
+    // Handle undefined (for ignored binary fields)
+    if (value === undefined) {
+        return '';
+    }
+    // Handle null
+    if (value === null) {
+        return 'null';
+    }
+    // Handle primitives
+    if (typeof value !== 'object' || value instanceof Date) {
+        return JSON.stringify(value);
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map((item) => {
+            const itemSchema = schema.items || {};
+            const formattedItem = formatWithDescriptions(item, itemSchema, rootSchema, comment, stripQuotes, indent + nestingIndent, // Use nestingIndent instead of hardcoded 4
+            nestingIndent, ignoreBinary, false);
+            return `${indentStr}${nestIndentStr}${formattedItem}`; // Use nestIndentStr for item indentation
+        });
+        return `[\n${items.join(',\n')}\n${indentStr}]`;
+    }
+    // Handle objects
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const formattedEntries = [];
+        // Add top-level description for objects
+        if (isTopLevel && schema.type === 'object' && schema.description) {
+            const descLines = schema.description.split('\n');
+            formattedEntries.push(`${indentStr}${nestIndentStr}${comment} -----`);
+            descLines.forEach((line) => {
+                formattedEntries.push(`${indentStr}${nestIndentStr}${comment} ${line.trim()}`);
+            });
+            formattedEntries.push(`${indentStr}${nestIndentStr}${comment} -----`);
+        }
+        entries.forEach(([key, val], index) => {
+            const propSchema = schema.properties?.[key] ?? {};
+            // Handle $ref in property schema
+            let resolvedPropSchema = propSchema;
+            if (propSchema.$ref) {
+                resolvedPropSchema = resolveRef(propSchema.$ref, rootSchema);
+            }
+            // Add property description if it exists
+            if (resolvedPropSchema.description) {
+                const descLines = resolvedPropSchema.description.split('\n');
+                descLines.forEach((line) => {
+                    formattedEntries.push(`${indentStr}${nestIndentStr}${comment} ${line.trim()}`);
+                });
+            }
+            // Format the key
+            const formattedKey = stripQuotes && /^[A-Za-z_$][0-9A-Za-z_$]*$/.test(key) ? key : JSON.stringify(key);
+            // Format the value
+            const formattedValue = formatWithDescriptions(val, resolvedPropSchema, rootSchema, comment, stripQuotes, indent + nestingIndent, nestingIndent, ignoreBinary, false);
+            formattedEntries.push(`${indentStr}${nestIndentStr}${formattedKey}: ${formattedValue}${index < entries.length - 1 ? ',' : ''}`);
+        });
+        return `{\n${formattedEntries.join('\n')}\n${indentStr}}`;
+    }
+    return JSON.stringify(value);
+}
+function resolveRef(ref, rootSchema) {
+    const path = ref.split('/').slice(1);
+    let current = rootSchema;
+    for (const segment of path) {
+        current = current[segment];
+        if (current === undefined) {
+            return {};
+        }
+    }
+    return current;
+}
+function handleRef(ref, rootSchema, ignoreBinary) {
+    const resolved = resolveRef(ref, rootSchema);
+    return getSampleValue(resolved, rootSchema, ignoreBinary);
+}
+function handleString(schema) {
+    if (schema.format) {
+        switch (schema.format) {
+            case 'email':
+            case 'idn-email':
+                return 'user@example.com';
+            case 'uri':
+            case 'url':
+            case 'iri':
+                return 'https://example.com';
+            case 'date':
+                return '2023-01-01';
+            case 'date-time':
+                return '2023-01-01T00:00:00Z';
+            case 'time':
+                return '12:00:00Z';
+            case 'duration':
+                return 'PT1H';
+            case 'uuid':
+                return '00000000-0000-0000-0000-000000000000';
+            case 'regex':
+                return '^[a-zA-Z0-9]+$';
+            case 'relative-json-pointer':
+                return '/some/relative/path';
+            case 'color':
+                return '#000000';
+            case 'hostname':
+                return 'example.com';
+            case 'zipcode':
+                return '12345';
+            case 'phone':
+                return '+123-456-7890';
+            case 'password':
+                return '******';
+            case 'binary':
+                return 'binary-data';
+            default:
+                return 'string';
+        }
+    }
+    if (schema.pattern) {
+        return 'pattern-string';
+    }
+    return 'string';
+}
+function handleNumber(schema) {
+    if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.maximum !== undefined) {
+        return schema.maximum;
+    }
+    return 0;
+}
+function handleBoolean() {
+    return true;
+}
+function handleObject(schema, rootSchema, ignoreBinary) {
+    const result = {};
+    if (schema.properties) {
+        const required = schema.required || [];
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (required.includes(key) || required.length === 0) {
+                const value = getSampleValue(propSchema, rootSchema, ignoreBinary);
+                // Only add the property if it's not undefined (which happens when ignoreBinary is true and it's a binary field)
+                if (value !== undefined) {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        const value = getSampleValue(schema.additionalProperties, rootSchema, ignoreBinary);
+        if (value !== undefined) {
+            result['additionalProp'] = value;
+        }
+    }
+    return result;
+}
+function handleArray(schema, rootSchema, ignoreBinary) {
+    if (schema.items) {
+        const itemSchema = schema.items;
+        // Check if the items are binary strings that should be ignored
+        if (ignoreBinary && itemSchema.type === 'string' && itemSchema.format === 'binary') {
+            return undefined;
+        }
+        const minItems = schema.minItems || 1;
+        const numItems = Math.min(minItems, 3);
+        const items = Array.from({ length: numItems }, () => getSampleValue(itemSchema, rootSchema, ignoreBinary)).filter((item) => item !== undefined); // Filter out undefined values from ignored binary items
+        // If all items were filtered out (e.g., all were binary), return undefined instead of empty array
+        if (items.length === 0 && numItems > 0) {
+            return undefined;
+        }
+        return items;
+    }
+    return [];
+}

package/cjs/utils/getJSONSchemaSample.d.ts

@@ -0,0 +1,2 @@
+import { KnownAny } from '../types';
+export declare function getJSONSchemaSample(schema: KnownAny, rootSchema?: KnownAny): KnownAny;