@innet/server 2.0.0-beta.8 → 2.0.0-beta.9

package/plugins/schema/field/field.d.ts

@@ -0,0 +1,10 @@
+import { type HandlerPlugin } from 'innet';
+export interface FieldProps {
+    children?: any;
+    deprecated?: boolean;
+    key: string;
+    optional?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+}
+export declare const field: HandlerPlugin;

package/plugins/schema/field/index.d.ts

@@ -0,0 +1 @@
+export * from './field';

package/plugins/schema/index.d.ts

@@ -0,0 +1,13 @@
+export * from './any';
+export * from './array';
+export * from './binary';
+export * from './boolean';
+export * from './date';
+export * from './field';
+export * from './integer';
+export * from './null';
+export * from './number';
+export * from './object';
+export * from './string';
+export * from './tuple';
+export * from './uuid';

package/plugins/schema/integer/index.d.ts

@@ -0,0 +1 @@
+export * from './integer';

package/plugins/schema/integer/integer.d.ts

@@ -0,0 +1,45 @@
+import { type HandlerPlugin } from 'innet';
+import { type IntegerFormats, type ValuesSchemaProps } from '../../../types';
+export interface IntegerProps extends ValuesSchemaProps<bigint | number> {
+    /**
+     * The `exclusiveMaximum` keyword is used to restrict the value to be less than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer exclusiveMaximum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMaximum?: bigint | boolean | number;
+    /**
+     * The `exclusiveMinimum` keyword is used to restrict the value to be greater than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer exclusiveMinimum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMinimum?: bigint | boolean | number;
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer format='int64' />
+     * ```
+     * @see https://swagger.io/docs/specification/data-models/data-types/#numbers
+     * */
+    format?: IntegerFormats;
+    /** Validate the integer number value by maximum. */
+    max?: bigint | number;
+    /** Validate the integer number value by minimum. */
+    min?: bigint | number;
+    /**
+     * The `multipleOf` keyword is used to restrict the value to be a multiple of the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number multipleOf={2} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    multipleOf?: bigint | number;
+}
+export declare const integer: HandlerPlugin;

package/plugins/schema/null/index.d.ts

@@ -0,0 +1 @@
+export * from './null';

package/plugins/schema/null/null.d.ts

@@ -0,0 +1,5 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface NullProps extends BaseSchemaProps<null> {
+}
+export declare const nullPlugin: HandlerPlugin;

package/plugins/schema/number/index.d.ts

@@ -0,0 +1 @@
+export * from './number';

package/plugins/schema/number/number.d.ts

@@ -0,0 +1,41 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+export interface NumberProps extends ValuesSchemaProps<number> {
+    /**
+     * The `exclusiveMaximum` keyword is used to restrict the value to be less than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number exclusiveMaximum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMaximum?: boolean;
+    /**
+     * The `exclusiveMinimum` keyword is used to restrict the value to be greater than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number exclusiveMinimum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMinimum?: boolean;
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    format?: 'double' | 'float' | (string & {});
+    /** Validate the number value by maximum. */
+    max?: number;
+    /** Validate the number value by minimum. */
+    min?: number;
+    /**
+     * The `multipleOf` keyword is used to restrict the value to be a multiple of the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number multipleOf={2} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    multipleOf?: number;
+}
+export declare const number: HandlerPlugin;

package/plugins/schema/object/index.d.ts

@@ -0,0 +1 @@
+export * from './object';

package/plugins/schema/object/object.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface ObjectProps extends BaseSchemaProps<object> {
+    children?: any;
+}
+export declare const object: HandlerPlugin;

package/plugins/schema/string/index.d.ts

@@ -0,0 +1 @@
+export * from './string';

package/plugins/schema/string/string.d.ts

@@ -0,0 +1,36 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+export interface StringProps extends ValuesSchemaProps<string> {
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    format?: 'binary' | 'byte' | 'date' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'password' | 'uri' | 'uuid' | (string & {});
+    /**
+     * String length can be restricted using `min` and `max`.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    max?: number;
+    /**
+     * String length can be restricted using `min` and `max`.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    min?: number;
+    /**
+     * The pattern keyword lets you define a regular expression template for the string value.
+     * Only the values that match this template will be accepted.
+     * The regular expression syntax used is from JavaScript (more specifically, ECMA 262).
+     * Regular expressions are case-sensitive, that is, [a-z] and [A-Z] are different expressions.
+     * @example For example, the following pattern matches a Social Security Number (SSN) in the 123-45-6789 format:
+     * ```tsx
+     * <string pattern='^\d{3}-\d{2}-\d{4}$' />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    pattern?: RegExp | string;
+    /**
+     * The `patternId` keyword is used to reference a pattern from the OpenAPI specification.
+     * */
+    patternId?: string;
+}
+export declare const string: HandlerPlugin;

package/plugins/schema/tuple/index.d.ts

@@ -0,0 +1 @@
+export * from './tuple';

package/plugins/schema/tuple/tuple.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface TupleProps extends BaseSchemaProps<any[]> {
+    children?: any;
+}
+export declare const tuple: HandlerPlugin;

package/plugins/schema/tuple/tuple.es6.js

@@ -22,6 +22,7 @@ const tuple = () => {
     if (schema) {
         const schemas = [];
         handler[schemaContext.key] = schemas;
+        // @ts-expect-error: FIXME
         schema.prefixItems = schemas;
         const rulesMap = [];
         const rules = [];

package/plugins/schema/tuple/tuple.js

@@ -26,6 +26,7 @@ const tuple = () => {
     if (schema) {
         const schemas = [];
         handler[useSchemaContext.schemaContext.key] = schemas;
+        // @ts-expect-error: FIXME
         schema.prefixItems = schemas;
         const rulesMap = [];
         const rules = [];

package/plugins/schema/uuid/index.d.ts

@@ -0,0 +1 @@
+export * from './uuid';

package/plugins/schema/uuid/uuid.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+export interface UuidProps extends ValuesSchemaProps<string> {
+    default?: 'new' | string;
+}
+export declare const uuid: HandlerPlugin;

package/plugins/schema/uuid/uuid.es6.js

@@ -16,8 +16,10 @@ const uuid = () => {
         ...props,
         default: defaultValue === 'new' ? undefined : defaultValue,
     });
+    // @ts-expect-error: FIXME
     schema.format = 'uuid';
     if (defaultValue === 'new') {
+        // @ts-expect-error: FIXME
         schema['x-default'] = defaultValue;
     }
     const rules = [];

package/plugins/schema/uuid/uuid.js

@@ -20,8 +20,10 @@ const uuid = () => {
         ...props,
         default: defaultValue === 'new' ? undefined : defaultValue,
     });
+    // @ts-expect-error: FIXME
     schema.format = 'uuid';
     if (defaultValue === 'new') {
+        // @ts-expect-error: FIXME
         schema['x-default'] = defaultValue;
     }
     const rules = [];

package/plugins/utils/blacklist/blacklist.d.ts

@@ -0,0 +1,5 @@
+export interface BlacklistProps {
+    children?: any;
+    ip?: string | string[];
+}
+export declare function blacklist(): void;

package/plugins/utils/blacklist/index.d.ts

@@ -0,0 +1 @@
+export * from './blacklist';

package/plugins/utils/dts/dts.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+export interface DtsProps {
+    namespace?: string;
+    path?: string;
+}
+export declare const dts: HandlerPlugin;

package/plugins/utils/dts/index.d.ts

@@ -0,0 +1 @@
+export * from './dts';

package/plugins/utils/env/env.d.ts

@@ -0,0 +1,7 @@
+import { type HandlerPlugin } from 'innet';
+export interface EnvProps {
+    children?: any;
+    is: string | string[];
+    of?: string;
+}
+export declare const env: HandlerPlugin;

package/plugins/utils/env/index.d.ts

@@ -0,0 +1 @@
+export * from './env';

package/plugins/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './blacklist';
+export * from './dts';
+export * from './env';
+export * from './protection';
+export * from './swagger';
+export * from './ui';
+export * from './whitelist';

package/plugins/utils/protection/index.d.ts

@@ -0,0 +1 @@
+export * from './protection';

package/plugins/utils/protection/protection.d.ts

@@ -0,0 +1,9 @@
+export interface ProtectionProps {
+    children?: any;
+    cookieKey?: string;
+    excludeIp?: string | string[];
+    maxAge?: number;
+    searchKey?: string;
+    value?: string;
+}
+export declare function protection(): void;

package/plugins/utils/swagger/index.d.ts

@@ -0,0 +1 @@
+export * from './swagger';

package/plugins/utils/swagger/swagger.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+export interface SwaggerProps {
+    path?: string;
+}
+/** @deprecated Use <ui> */
+export declare const swagger: HandlerPlugin;

package/plugins/utils/swagger/swagger.es6.js

@@ -5,6 +5,7 @@ import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { useServerPlugin } from '../../../hooks/useServerPlugin/useServerPlugin.es6.js';
 import { useAction } from '../../../hooks/useAction/useAction.es6.js';
 
+/** @deprecated Use <ui> */
 const swagger = () => {
     const { path = process.env.INNET_SWAGGER_PATH || '/swagger-ui', } = useProps() || {};
     const { docs, prefix, } = useApi();

package/plugins/utils/swagger/swagger.js

@@ -9,6 +9,7 @@ var useApi = require('../../../hooks/useApi/useApi.js');
 var useServerPlugin = require('../../../hooks/useServerPlugin/useServerPlugin.js');
 var useAction = require('../../../hooks/useAction/useAction.js');
 
+/** @deprecated Use <ui> */
 const swagger = () => {
     const { path = process.env.INNET_SWAGGER_PATH || '/swagger-ui', } = jsx.useProps() || {};
     const { docs, prefix, } = useApi.useApi();

package/plugins/utils/ui/index.d.ts

@@ -0,0 +1 @@
+export * from './ui';

package/plugins/utils/ui/ui.d.ts

@@ -0,0 +1,13 @@
+import { type HandlerPlugin } from 'innet';
+export declare const uiPresets: {
+    rapidoc: string;
+    redoc: string;
+    scalar: string;
+    swagger: string;
+};
+export interface UiProps {
+    html?: string;
+    params?: Record<string, any>;
+    path?: string;
+}
+export declare const ui: HandlerPlugin;

package/plugins/utils/whitelist/index.d.ts

@@ -0,0 +1 @@
+export * from './whitelist';

package/plugins/utils/whitelist/whitelist.d.ts

@@ -0,0 +1,5 @@
+export interface WhitelistProps {
+    children?: any;
+    ip?: string | string[];
+}
+export declare function whitelist(): void;

package/types.d.ts

@@ -0,0 +1,69 @@
+import type { OpenAPIV3_1 as API } from 'openapi-types';
+import type { ApiErrorValue } from './constants';
+import { type ServerPlugin } from './hooks';
+import { type Rule, type RulesErrors } from './utils/rules';
+export type TagObject = API.TagObject;
+export type Document = API.Document;
+export type ServerObject = API.ServerObject;
+export type OperationObject = API.OperationObject;
+export type ResponseObject = API.ResponseObject;
+export type SchemaObject = API.SchemaObject;
+export type ArraySchemaObjectType = API.ArraySchemaObjectType;
+export type NonArraySchemaObjectType = API.NonArraySchemaObjectType;
+export type ArraySchemaObject = API.ArraySchemaObject;
+export type ReferenceObject = API.ReferenceObject;
+export type ParameterObject = API.ParameterObject;
+export type RequestBodyObject = API.RequestBodyObject;
+export type ObjectType = ArraySchemaObjectType | NonArraySchemaObjectType;
+export type RefSchemaObject = ReferenceObject | SchemaObject;
+export type Effect = () => void;
+export interface IValidationErrorData extends Record<string, any> {
+    error: RulesErrors;
+}
+export type ValidationErrorData = IValidationErrorData | undefined;
+export interface EndpointRules {
+    body?: Rule;
+    cookie?: Rule;
+    header?: Rule;
+    path?: Rule;
+    response?: Rule;
+    search?: Rule;
+}
+export interface EndpointRulesMaps {
+    cookie?: Record<string, Rule>;
+    header?: Record<string, Rule>;
+    path?: Record<string, Rule>;
+    search?: Record<string, Rule>;
+}
+export interface Endpoint<I = unknown, O = unknown, E extends ApiErrorValue = ApiErrorValue, P extends InValidationErrorParam = InValidationErrorParam, D extends ValidationErrorData = ValidationErrorData> {
+    dynamic?: Endpoint<I, O, E, P, D>[];
+    key: string;
+    plugins: Set<ServerPlugin>;
+    rules?: EndpointRules;
+    rulesMaps?: EndpointRulesMaps;
+    static?: Record<string, Endpoint<I, O, E, P, D>>;
+}
+export type IntegerFormats = 'int32' | 'int64';
+export type EndpointsMethods = 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+export type InParam = 'cookie' | 'header' | 'path' | 'query';
+export type InValidationErrorParam = 'body' | InParam;
+export type BodyType = 'application/json' | 'application/x-www-form-urlencoded' | 'multipart/form-data';
+export type Endpoints<I = unknown, O = unknown, E extends ApiErrorValue = ApiErrorValue, P extends InValidationErrorParam = InValidationErrorParam, D extends ValidationErrorData = ValidationErrorData> = Partial<Record<EndpointsMethods, Endpoint<I, O, E, P, D>>>;
+export interface SSL {
+    cert: string;
+    key: string;
+}
+export interface ServerStartParams {
+    https: boolean;
+    port: number;
+}
+export interface BaseSchemaProps<T> {
+    default?: T;
+    description?: string;
+    example?: T;
+    examples?: T[];
+    ref?: string;
+}
+export interface ValuesSchemaProps<T> extends BaseSchemaProps<T> {
+    values?: T[];
+}

package/utils/FileData/Bin.d.ts

@@ -0,0 +1,47 @@
+export interface BinOptions {
+    disposition: string;
+    /**
+     * A field name of FormData request
+     */
+    fieldName: string;
+    /**
+     * Full origin file name
+     */
+    originalFilename: string;
+    /**
+     * Full path to the file on server, you MUST use it only on server side for the safe
+     */
+    path: string;
+    /**
+     * The file size
+     */
+    size: number;
+    /**
+     * MIME-type of the file
+     */
+    type: string;
+}
+export declare class Bin implements BinOptions {
+    disposition: string;
+    /**
+     * The extension of the origin file from originalFilename
+     */
+    extension?: string;
+    fieldName: string;
+    /**
+     * A file name, without extension
+     */
+    filename: string;
+    originalFilename: string;
+    path: string;
+    size: number;
+    type: string;
+    constructor(options: BinOptions);
+    toJSON(): {
+        $: string;
+        disposition: string;
+        originalFilename: string;
+        size: number;
+        type: string;
+    };
+}

package/utils/FileData/index.d.ts

@@ -0,0 +1 @@
+export * from './Bin';

package/utils/JSONString/JSONString.d.ts

@@ -0,0 +1 @@
+export declare function JSONString(target: any): string;

package/utils/JSONString/index.d.ts

@@ -0,0 +1 @@
+export * from './JSONString';

package/utils/action/Action.d.ts

@@ -0,0 +1,31 @@
+import { type Cookies, type SerializeOptions } from 'cookie';
+import { type IncomingHttpHeaders, type IncomingMessage, type ServerResponse } from 'http';
+import { type ParsedQs } from 'qs';
+import { type BodyType } from '../../types';
+export declare const URL_PARSER: RegExp;
+export interface ParsedUrl {
+    path: string;
+    search?: string;
+}
+export declare class Action {
+    #private;
+    readonly req: IncomingMessage;
+    readonly res: ServerResponse;
+    body?: object;
+    constructor(req: IncomingMessage, res: ServerResponse);
+    parseBody(): Promise<void>;
+    setCookie(name: string, value?: string, options?: SerializeOptions): void;
+    get bodyType(): BodyType | undefined;
+    get clientIp(): string | null;
+    get cookies(): Cookies;
+    set cookies(value: Record<string, string>);
+    get headers(): IncomingHttpHeaders;
+    set headers(value: IncomingHttpHeaders);
+    get originCookies(): Cookies;
+    get originHeaders(): IncomingHttpHeaders;
+    get originSearch(): ParsedQs;
+    get parsedUrl(): ParsedUrl;
+    get path(): string;
+    get search(): ParsedQs;
+    set search(value: ParsedQs);
+}

package/utils/action/index.d.ts

@@ -0,0 +1 @@
+export * from './Action';

package/utils/dateFormat/dateFormat.d.ts

@@ -0,0 +1,2 @@
+export type DateFormat = 'now' | Date | number | string;
+export declare function dateFormat(date?: DateFormat): Date | undefined;

package/utils/dateFormat/index.d.ts

@@ -0,0 +1 @@
+export * from './dateFormat';

package/utils/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './once';

package/utils/decorators/once/index.d.ts

@@ -0,0 +1 @@
+export * from './once';

package/utils/decorators/once/once.d.ts

@@ -0,0 +1,4 @@
+export declare function once<This, Args extends any[], Result = unknown>(target: (this: This, ...args: Args) => Result, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Result>): any;
+export declare function once<This, Args extends any[]>(target: (this: This, value: Args[0]) => void, context: ClassSetterDecoratorContext<This, Args[0]>): any;
+export declare function once<This, Value>(value: () => Value, context: ClassGetterDecoratorContext<This, Value>): any;
+export declare function once<This, Args extends any[], Result = unknown>(target: undefined, context: ClassFieldDecoratorContext<This, (...args: Args) => Result>): any;

package/utils/decorators/once/once.es6.js

@@ -1,5 +1,6 @@
 const secretKey = Symbol('once');
 function getCacheObject(target) {
+    // @ts-expect-error: FIXME
     return target[secretKey] || (target[secretKey] = {});
 }
 function once(target, context) {
@@ -9,14 +10,17 @@ function once(target, context) {
             return function () {
                 if (cache !== secretKey)
                     return cache;
+                // @ts-expect-error: FIXME
                 return (cache = ('apply' in fn ? fn.apply(this, arguments) : fn(...arguments)));
             };
         }
         : function once() {
+            // @ts-expect-error: FIXME
             const map = getCacheObject(this);
             if (context.name in map) {
                 return map[context.name];
             }
+            // @ts-expect-error: FIXME
             return (map[context.name] = target.apply(this, arguments));
         };
 }

package/utils/decorators/once/once.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const secretKey = Symbol('once');
 function getCacheObject(target) {
+    // @ts-expect-error: FIXME
     return target[secretKey] || (target[secretKey] = {});
 }
 function once(target, context) {
@@ -13,14 +14,17 @@ function once(target, context) {
             return function () {
                 if (cache !== secretKey)
                     return cache;
+                // @ts-expect-error: FIXME
                 return (cache = ('apply' in fn ? fn.apply(this, arguments) : fn(...arguments)));
             };
         }
         : function once() {
+            // @ts-expect-error: FIXME
             const map = getCacheObject(this);
             if (context.name in map) {
                 return map[context.name];
             }
+            // @ts-expect-error: FIXME
             return (map[context.name] = target.apply(this, arguments));
         };
 }

package/utils/generateTypes/generateTypes.d.ts

@@ -0,0 +1,3 @@
+import { type Document, type SchemaObject } from '../../types';
+export declare function generateSchemaTypes(schema: SchemaObject, spaces?: number, lastChar?: string): string;
+export declare function generateTypes(docs: Document, namespace?: string): string;

package/utils/generateTypes/generateTypes.es6.js

@@ -95,6 +95,7 @@ function generateTypes(docs, namespace = 'Api') {
     for (const path in paths) {
         const pathObject = paths[path];
         for (const method in pathObject) {
+            // @ts-expect-error: FIXME
             const endpoint = pathObject[method];
             const parameters = endpoint.parameters;
             const requestBody = endpoint.requestBody;

package/utils/generateTypes/generateTypes.js

@@ -99,6 +99,7 @@ function generateTypes(docs, namespace = 'Api') {
     for (const path in paths) {
         const pathObject = paths[path];
         for (const method in pathObject) {
+            // @ts-expect-error: FIXME
             const endpoint = pathObject[method];
             const parameters = endpoint.parameters;
             const requestBody = endpoint.requestBody;

package/utils/generateTypes/index.d.ts

@@ -0,0 +1 @@
+export * from './generateTypes';

package/utils/getEndpoint/getEndpoint.d.ts

@@ -0,0 +1,2 @@
+import { type Endpoint } from '../../types';
+export declare function getEndpoint(path: string, parentEndpoint: Endpoint): Endpoint<unknown, unknown, "requestValidation" | "requestBodyContentType", import("../../types").InValidationErrorParam, import("../../types").ValidationErrorData> | undefined;

package/utils/getEndpoint/index.d.ts

@@ -0,0 +1 @@
+export * from './getEndpoint';

package/utils/getOrAdd/getOrAdd.d.ts

@@ -0,0 +1 @@
+export declare function getOrAdd<R = any>(target: object, path: number | string, defaultValues: any[]): R;