vovk 3.0.0-draft.99 → 3.0.0

package/dist/types/standard-schema.d.ts

@@ -0,0 +1,117 @@
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}

package/dist/types/standard-schema.js

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-namespace */
+// #########################
+// ###   Standard Typed  ###
+// #########################
+export {};

package/dist/types/tools.d.ts

@@ -0,0 +1,43 @@
+import type { VovkJSONSchemaBase } from './json-schema.js';
+import type { VovkRequest } from './request.js';
+import type { CombinedSpec } from './validation.js';
+import type { KnownAny } from './utils.js';
+export type ToModelOutputFn<TInput, TOutput, TFormattedOutput> = (result: TOutput | Error, tool: VovkTool<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => TFormattedOutput | Promise<TFormattedOutput>;
+interface VovkToolCommon<TInput = unknown, TOutput = unknown, TFormattedOutput = unknown, TIsDerived extends boolean = boolean> {
+    execute: (input: TInput, options?: unknown) => TFormattedOutput | Promise<TFormattedOutput>;
+    name: string;
+    title: string | undefined;
+    description: string;
+    parameters: {
+        type?: 'object';
+        properties?: {
+            body?: VovkJSONSchemaBase;
+            query?: VovkJSONSchemaBase;
+            params?: VovkJSONSchemaBase;
+        };
+        required?: ('body' | 'query' | 'params')[];
+        additionalProperties?: false;
+    };
+    inputSchema: TIsDerived extends true ? undefined : TInput extends undefined ? undefined : CombinedSpec<TInput>;
+    outputSchema: TIsDerived extends true ? CombinedSpec | undefined : TOutput extends undefined ? undefined : CombinedSpec<TOutput>;
+    inputSchemas: TIsDerived extends true ? {
+        body?: CombinedSpec;
+        query?: CombinedSpec;
+        params?: CombinedSpec;
+    } : undefined;
+    type: 'function';
+}
+export type VovkToolDerived<TInput, TOutput, TFormattedOutput> = VovkToolCommon<TInput, TOutput, TFormattedOutput, true>;
+export type VovkToolNonDerived<TInput, TOutput, TFormattedOutput> = VovkToolCommon<TInput, TOutput, TFormattedOutput, false>;
+/**
+ * Vovk tool type, which can be either derived or non-derived.
+ * @see https://vovk.dev/tools
+ */
+export type VovkTool<TInput = KnownAny, TOutput = KnownAny, TFormattedOutput = KnownAny> = VovkToolDerived<TInput, TOutput, TFormattedOutput> | VovkToolNonDerived<TInput, TOutput, TFormattedOutput>;
+export type VovkToolOptions = {
+    hidden?: boolean;
+    name?: string;
+    title?: string;
+    description?: string;
+};
+export {};

package/dist/types/tools.js

@@ -0,0 +1 @@
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,9 @@
+export type RequireFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type IsEmptyObject<T> = T extends object ? keyof T extends never ? true : T extends Partial<T> ? Partial<T> extends T ? true : false : false : false;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type KnownAny = any;
+export type StaticClass = Function;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsNotAny<T> = IsAny<T> extends true ? false : true;

package/dist/types/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/types/validation.d.ts

@@ -0,0 +1,48 @@
+import type { StandardSchemaV1, StandardJSONSchemaV1 } from './standard-schema.js';
+import type { KnownAny } from './utils.js';
+import type { VovkHandlerSchema, VovkSchema } from './core.js';
+import type { textTypes } from '../req/parseBody.js';
+export interface CombinedProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
+}
+/**
+ * An interface that combines StandardJSONSchema and StandardSchema.
+ * */
+export interface CombinedSpec<Input = unknown, Output = Input> {
+    '~standard': CombinedProps<Input, Output>;
+}
+export declare namespace CombinedSpec {
+    type Target = StandardJSONSchemaV1.Target;
+    type InferInput<T extends StandardSchemaV1> = StandardSchemaV1.InferInput<T>;
+    type InferOutput<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+    type SuccessResult<T> = StandardSchemaV1.SuccessResult<T>;
+}
+/** Application MIME types that are parsed as text (derived from parseBody.ts textTypes). */
+type TextLikeApplicationType = (typeof textTypes)[number];
+export type ContentType = 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded' | 'text/plain' | 'application/octet-stream' | TextLikeApplicationType | `text/${string}` | `application/${string}` | `${string}+json` | `${string}+xml` | `${string}+text` | `${string}+yaml` | `${string}+json-seq` | '*/*' | (string & {});
+export type NormalizeContentType<T extends ContentType | ContentType[]> = T extends ContentType[] ? T : [T & ContentType];
+export type BodyTypeFromContentType<T extends ContentType[], TBody> = T[number] extends infer A ? A extends '*/*' ? TBody | URLSearchParams | FormData | ArrayBuffer | Uint8Array | Blob : A extends 'application/json' | `${string}+json` ? TBody | Blob : A extends 'multipart/form-data' ? TBody | FormData | Blob : A extends 'application/x-www-form-urlencoded' ? TBody | URLSearchParams | FormData | Blob : A extends `text/${string}` | TextLikeApplicationType | `${string}+xml` | `${string}+text` | `${string}+yaml` | `${string}+json-seq` ? string | Blob : ArrayBuffer | Uint8Array | Blob : never;
+export type VovkTypedProcedure<T extends (...args: KnownAny[]) => unknown, B = unknown, Q = unknown, P = unknown, O = unknown, I = unknown, TContentType extends ContentType | ContentType[] = ['application/json']> = T & {
+    __types: {
+        body: B;
+        query: Q;
+        params: P;
+        output: O;
+        iteration: I;
+        contentType: NormalizeContentType<TContentType>;
+    };
+    isRPC?: boolean;
+};
+/**
+ * Client-side validation function type.
+ * @see https://vovk.dev/imports
+ */
+export type VovkValidateOnClient<TFetcherOptions> = (input: {
+    body?: unknown;
+    query?: unknown;
+    params?: unknown;
+    meta?: unknown;
+} & TFetcherOptions, validation: Omit<Exclude<VovkHandlerSchema['validation'], undefined>, 'output' | 'iteration'>, meta: {
+    fullSchema: VovkSchema;
+    endpoint: string;
+}) => KnownAny | Promise<KnownAny>;
+export {};

package/dist/types/validation.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/camelCase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts string to camel case.
+ * @param {*} input - The value to convert to camel case.
+ * @returns {string}
+ */
+export declare function camelCase(input: string): string;

package/dist/utils/camelCase.js

@@ -0,0 +1,34 @@
+// Convert any value to string
+function toString(value) {
+    return value == null ? '' : String(value);
+}
+// Regex to match words (including Unicode letters & digits)
+const reUnicodeWord = /[\p{Lu}]{2,}(?=[\p{Lu}][\p{Ll}]+[0-9]*|\b)|[\p{Lu}]?[\p{Ll}]+[0-9]*|[\p{Lu}]|[0-9]+/gu;
+/**
+ * Splits string into an array of words based on Unicode word boundaries
+ * @param {string} str
+ * @returns {string[]}
+ */
+function unicodeWords(str) {
+    return str.match(reUnicodeWord) || [];
+}
+/**
+ * Converts string to camel case.
+ * @param {*} input - The value to convert to camel case.
+ * @returns {string}
+ */
+export function camelCase(input) {
+    const str = toString(input);
+    // replace separators with space
+    const sanitized = str.replace(/[\s_-]+/g, ' ').trim();
+    const words = unicodeWords(sanitized);
+    return words
+        .map((word, index) => {
+        const lower = word.toLowerCase();
+        if (index === 0) {
+            return lower;
+        }
+        return lower.charAt(0).toUpperCase() + lower.slice(1);
+    })
+        .join('');
+}

package/dist/utils/deepExtend.d.ts

@@ -0,0 +1,53 @@
+/*!
+ * @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 { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
+export type { DeepPartial, SpecificValue };

package/dist/utils/deepExtend.js

@@ -0,0 +1,128 @@
+/* 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';
+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;
+}
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };

package/dist/utils/fileNameToDisposition.d.ts

@@ -0,0 +1 @@
+export declare function fileNameToDisposition(filename: string): string;

package/dist/utils/fileNameToDisposition.js

@@ -0,0 +1,3 @@
+export function fileNameToDisposition(filename) {
+    return `attachment; filename="${filename.replace(/[^\x20-\x7E]|"/g, '_')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}

package/dist/utils/shim.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/shim.js

@@ -1,4 +1,3 @@
-"use strict";
 if (typeof Symbol.dispose !== 'symbol') {
     Object.defineProperty(Symbol, 'dispose', {
         configurable: false,
@@ -15,3 +14,4 @@ if (typeof Symbol.asyncDispose !== 'symbol') {
         value: Symbol.for('asyncDispose'),
     });
 }
+export {};

package/dist/utils/toKebabCase.d.ts

@@ -0,0 +1 @@
+export declare const toKebabCase: (str: string) => string;

package/dist/utils/toKebabCase.js

@@ -0,0 +1,5 @@
+export const toKebabCase = (str) => str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // Add hyphen between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2') // Add hyphen between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^-/, ''); // Remove leading hyphen

package/dist/utils/trimPath.d.ts

@@ -0,0 +1 @@
+export declare const trimPath: (path: string) => string;

package/dist/utils/trimPath.js

@@ -0,0 +1 @@
+export const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');

package/dist/utils/upperFirst.d.ts

@@ -0,0 +1 @@
+export declare function upperFirst(str: string): string;

package/dist/utils/upperFirst.js

@@ -0,0 +1,3 @@
+export function upperFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}