@innet/server 2.0.0-beta.25 → 2.0.0-beta.27

package/constants.d.ts

@@ -1,4 +1,7 @@
+import { type OpenAPIV3_1 } from 'openapi-types';
 import { type BodyType } from './types';
 export declare const apiErrors: readonly ["requestValidation", "requestBodyContentType"];
 export type ApiErrorValue = typeof apiErrors[number];
 export declare const allBodyTypes: BodyType[];
+export declare const defaultRequestBodyContentTypeSchema: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.SchemaObject;
+export declare const defaultRequestValidationSchema: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.SchemaObject;

package/constants.es6.js

@@ -1,3 +1,5 @@
+import { rulesErrorSchemas } from './utils/rules/constants.es6.js';
+
 const apiErrors = [
     'requestValidation',
     'requestBodyContentType',
@@ -7,5 +9,30 @@ const allBodyTypes = [
     'application/x-www-form-urlencoded',
     'multipart/form-data',
 ];
+const defaultRequestBodyContentTypeSchema = {
+    description: 'The request has no body or has unsupported content type format',
+    properties: {
+        error: {
+            const: 'requestBodyContentType',
+            title: 'The error code',
+            type: 'string',
+        },
+    },
+    type: 'object',
+};
+const defaultRequestValidationSchema = {
+    description: 'The request contains invalid data',
+    properties: {
+        data: {
+            oneOf: Object.values(rulesErrorSchemas),
+        },
+        error: {
+            const: 'requestValidation',
+            title: 'The error code',
+            type: 'string',
+        },
+    },
+    type: 'object',
+};
 
-export { allBodyTypes, apiErrors };
+export { allBodyTypes, apiErrors, defaultRequestBodyContentTypeSchema, defaultRequestValidationSchema };

package/constants.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var constants = require('./utils/rules/constants.js');
+
 const apiErrors = [
     'requestValidation',
     'requestBodyContentType',
@@ -11,6 +13,33 @@ const allBodyTypes = [
     'application/x-www-form-urlencoded',
     'multipart/form-data',
 ];
+const defaultRequestBodyContentTypeSchema = {
+    description: 'The request has no body or has unsupported content type format',
+    properties: {
+        error: {
+            const: 'requestBodyContentType',
+            title: 'The error code',
+            type: 'string',
+        },
+    },
+    type: 'object',
+};
+const defaultRequestValidationSchema = {
+    description: 'The request contains invalid data',
+    properties: {
+        data: {
+            oneOf: Object.values(constants.rulesErrorSchemas),
+        },
+        error: {
+            const: 'requestValidation',
+            title: 'The error code',
+            type: 'string',
+        },
+    },
+    type: 'object',
+};
 
 exports.allBodyTypes = allBodyTypes;
 exports.apiErrors = apiErrors;
+exports.defaultRequestBodyContentTypeSchema = defaultRequestBodyContentTypeSchema;
+exports.defaultRequestValidationSchema = defaultRequestValidationSchema;

package/hooks/index.d.ts

@@ -2,7 +2,7 @@ export * from './useAction';
 export * from './useApi';
 export * from './useBlock';
 export * from './useBody';
-export * from './useBodyFile';
+export * from './useBodyContext';
 export * from './useClientIp';
 export * from './useComponentName';
 export * from './useCookies';

package/hooks/index.es6.js

@@ -2,7 +2,7 @@ import './useAction/index.es6.js';
 import './useApi/index.es6.js';
 import './useBlock/index.es6.js';
 import './useBody/index.es6.js';
-import './useBodyFile/index.es6.js';
+import './useBodyContext/index.es6.js';
 import './useClientIp/index.es6.js';
 import './useComponentName/index.es6.js';
 import './useCookies/index.es6.js';

package/hooks/index.js

@@ -4,7 +4,7 @@ require('./useAction/index.js');
 require('./useApi/index.js');
 require('./useBlock/index.js');
 require('./useBody/index.js');
-require('./useBodyFile/index.js');
+require('./useBodyContext/index.js');
 require('./useClientIp/index.js');
 require('./useComponentName/index.js');
 require('./useCookies/index.js');

package/hooks/useBodyContext/index.d.ts

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

package/hooks/useBodyContext/index.es6.js

@@ -0,0 +1 @@
+export { bodyContext, useBodyContext } from './useBodyContext.es6.js';

package/hooks/useBodyContext/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useBodyContext = require('./useBodyContext.js');
+
+
+
+exports.bodyContext = useBodyContext.bodyContext;
+exports.useBodyContext = useBodyContext.useBodyContext;

package/hooks/useBodyContext/useBodyContext.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '@innet/jsx';
+export interface BodyContext {
+    useFile: () => void;
+}
+export declare const bodyContext: Context<BodyContext, BodyContext | undefined>;
+export declare function useBodyContext(): BodyContext;

package/hooks/{useBodyFile/useBodyFile.es6.js → useBodyContext/useBodyContext.es6.js}

@@ -2,13 +2,13 @@ import { Context, useContext } from '@innet/jsx';
 import '../useThrow/index.es6.js';
 import { useThrow } from '../useThrow/useThrow.es6.js';
 
-const bodyFileContext = new Context();
-function useBodyFile() {
-    const bodyFile = useContext(bodyFileContext);
-    if (!bodyFile) {
+const bodyContext = new Context();
+function useBodyContext() {
+    const context = useContext(bodyContext);
+    if (!context) {
         useThrow('<{type}> MUST be in <body>');
     }
-    bodyFile();
+    return context;
 }
 
-export { bodyFileContext, useBodyFile };
+export { bodyContext, useBodyContext };

package/hooks/{useBodyFile/useBodyFile.js → useBodyContext/useBodyContext.js}

@@ -6,14 +6,14 @@ var jsx = require('@innet/jsx');
 require('../useThrow/index.js');
 var useThrow = require('../useThrow/useThrow.js');
 
-const bodyFileContext = new jsx.Context();
-function useBodyFile() {
-    const bodyFile = jsx.useContext(bodyFileContext);
-    if (!bodyFile) {
+const bodyContext = new jsx.Context();
+function useBodyContext() {
+    const context = jsx.useContext(bodyContext);
+    if (!context) {
         useThrow.useThrow('<{type}> MUST be in <body>');
     }
-    bodyFile();
+    return context;
 }
 
-exports.bodyFileContext = bodyFileContext;
-exports.useBodyFile = useBodyFile;
+exports.bodyContext = bodyContext;
+exports.useBodyContext = useBodyContext;

package/hooks/useData/useData.d.ts

@@ -2,5 +2,5 @@ import { type ApiEndpoints, type TEndpoint } from '../../types';
 type KeysWithField<F extends string> = {
     [K in keyof ApiEndpoints]: F extends keyof ApiEndpoints[K] ? K : never;
 }[keyof ApiEndpoints];
-export declare function useData<F extends Exclude<keyof TEndpoint, 'response'>, K extends KeysWithField<F> = KeysWithField<F>, T extends boolean = false>(from: F, path?: K, withThrow?: T): T extends true ? ApiEndpoints[K][F] : ApiEndpoints[K][F] | undefined;
+export declare function useData<F extends Exclude<keyof TEndpoint, 'response'>, K extends KeysWithField<F> = KeysWithField<F>, T extends boolean = false>(from: F, path?: K, preventThrow?: T): T extends true ? ApiEndpoints[K][F] | undefined : ApiEndpoints[K][F];
 export {};

package/hooks/useData/useData.es6.js

@@ -8,16 +8,16 @@ import { useThrow } from '../useThrow/useThrow.es6.js';
 import { useAction } from '../useAction/useAction.es6.js';
 import { paramsContext } from '../useParams/useParams.es6.js';
 
-function useData(from, path, withThrow) {
+function useData(from, path, preventThrow) {
     if (path) {
         const endpoint = useEndpoint();
         const endpointKey = `${endpoint.props.method.toUpperCase()}:${endpoint.props.path}`;
         if (endpointKey !== path) {
-            if (withThrow) {
-                useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
+            if (preventThrow) {
+                return undefined;
             }
             else {
-                return undefined;
+                useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
             }
         }
     }

package/hooks/useData/useData.js

@@ -12,16 +12,16 @@ var useThrow = require('../useThrow/useThrow.js');
 var useAction = require('../useAction/useAction.js');
 var useParams = require('../useParams/useParams.js');
 
-function useData(from, path, withThrow) {
+function useData(from, path, preventThrow) {
     if (path) {
         const endpoint = useEndpoint.useEndpoint();
         const endpointKey = `${endpoint.props.method.toUpperCase()}:${endpoint.props.path}`;
         if (endpointKey !== path) {
-            if (withThrow) {
-                useThrow.useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
+            if (preventThrow) {
+                return undefined;
             }
             else {
-                return undefined;
+                useThrow.useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
             }
         }
     }

package/index.es6.js

@@ -8,7 +8,7 @@ export { actionContext, useAction } from './hooks/useAction/useAction.es6.js';
 export { apiContext, useApi } from './hooks/useApi/useApi.es6.js';
 export { useBlock } from './hooks/useBlock/useBlock.es6.js';
 export { useBody } from './hooks/useBody/useBody.es6.js';
-export { bodyFileContext, useBodyFile } from './hooks/useBodyFile/useBodyFile.es6.js';
+export { bodyContext, useBodyContext } from './hooks/useBodyContext/useBodyContext.es6.js';
 export { useClientIp } from './hooks/useClientIp/useClientIp.es6.js';
 export { useComponentName } from './hooks/useComponentName/useComponentName.es6.js';
 export { useCookies } from './hooks/useCookies/useCookies.es6.js';
@@ -95,7 +95,7 @@ export { EMPTY_SEARCH, parseSearch } from './utils/parseSearch/parseSearch.es6.j
 export { arrayOf } from './utils/rules/arrayOf/arrayOf.es6.js';
 export { bin } from './utils/rules/bin/bin.es6.js';
 export { binaryAccept } from './utils/rules/binaryAccept/binaryAccept.es6.js';
-export { rulesErrors } from './utils/rules/constants.es6.js';
+export { inValidationValues, rulesErrorSchemas, rulesErrors } from './utils/rules/constants.es6.js';
 export { dateTo } from './utils/rules/dateTo/dateTo.es6.js';
 export { defaultTo } from './utils/rules/defaultTo/defaultTo.es6.js';
 export { RulesError, addKey } from './utils/rules/helpers.es6.js';

package/index.js

@@ -12,7 +12,7 @@ var useAction = require('./hooks/useAction/useAction.js');
 var useApi = require('./hooks/useApi/useApi.js');
 var useBlock = require('./hooks/useBlock/useBlock.js');
 var useBody = require('./hooks/useBody/useBody.js');
-var useBodyFile = require('./hooks/useBodyFile/useBodyFile.js');
+var useBodyContext = require('./hooks/useBodyContext/useBodyContext.js');
 var useClientIp = require('./hooks/useClientIp/useClientIp.js');
 var useComponentName = require('./hooks/useComponentName/useComponentName.js');
 var useCookies = require('./hooks/useCookies/useCookies.js');
@@ -140,8 +140,8 @@ exports.apiContext = useApi.apiContext;
 exports.useApi = useApi.useApi;
 exports.useBlock = useBlock.useBlock;
 exports.useBody = useBody.useBody;
-exports.bodyFileContext = useBodyFile.bodyFileContext;
-exports.useBodyFile = useBodyFile.useBodyFile;
+exports.bodyContext = useBodyContext.bodyContext;
+exports.useBodyContext = useBodyContext.useBodyContext;
 exports.useClientIp = useClientIp.useClientIp;
 exports.useComponentName = useComponentName.useComponentName;
 exports.useCookies = useCookies.useCookies;
@@ -252,6 +252,8 @@ exports.parseSearch = parseSearch.parseSearch;
 exports.arrayOf = arrayOf.arrayOf;
 exports.bin = bin.bin;
 exports.binaryAccept = binaryAccept.binaryAccept;
+exports.inValidationValues = constants.inValidationValues;
+exports.rulesErrorSchemas = constants.rulesErrorSchemas;
 exports.rulesErrors = constants.rulesErrors;
 exports.dateTo = dateTo.dateTo;
 exports.defaultTo = defaultTo.defaultTo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innet/server",
-  "version": "2.0.0-beta.25",
+  "version": "2.0.0-beta.27",
   "description": "Create server-side application with innet",
   "main": "index.js",
   "module": "index.es6.js",

package/plugins/main/api/api.d.ts

@@ -1,12 +1,19 @@
 import { type HandlerPlugin } from 'innet';
+import { type ApiErrorSchema, type ApiErrorSchemaRefs } from '../../../types';
 export interface ApiProps {
     children?: any;
     /** A description of the API. [CommonMark syntax](https://spec.commonmark.or.org) MAY be used for rich text representation. */
     description?: string;
+    /** URL path prefix scopes the API. */
+    errorShema?: Partial<ApiErrorSchema>;
+    /** Error schema reference names. */
+    errorShemaRefs?: Partial<ApiErrorSchemaRefs>;
     exclude?: RegExp;
     include?: RegExp;
     /** URL path prefix scopes the API. */
     prefix?: string;
+    /** It turns on auto-generation for schemas. */
+    schemaGeneration?: boolean;
     /** A short summary of the API. */
     summary?: string;
     /** A URL to the Terms of Service for the API. This MUST be in the form of a URL. */

package/plugins/main/api/api.es6.js

@@ -14,7 +14,7 @@ import { paramsContext } from '../../../hooks/useParams/useParams.es6.js';
 const api = () => {
     const handler = useNewHandler();
     const props = useProps();
-    const { children, exclude, include, prefix = process.env.INNET_API_PREFIX || '', title = '', version = process.env.INNET_API_VERSION || '0.0.0', ...rest } = props;
+    const { children, errorShema, errorShemaRefs, exclude, include, prefix = process.env.INNET_API_PREFIX || '', schemaGeneration, title = '', version = process.env.INNET_API_VERSION || '0.0.0', ...rest } = props;
     const info = { ...rest, title, version };
     const endpoints = {};
     const docs = {
@@ -120,9 +120,7 @@ const api = () => {
                         if (!action.body) {
                             res.statusCode = 400;
                             res.setHeader('Content-Type', 'application/json');
-                            res.write(JSONString({
-                                error: 'requestBodyContentType',
-                            }));
+                            res.write(JSONString({ error: 'requestBodyContentType' }));
                             res.end();
                             return true;
                         }

package/plugins/main/api/api.js

@@ -18,7 +18,7 @@ var useParams = require('../../../hooks/useParams/useParams.js');
 const api = () => {
     const handler = innet.useNewHandler();
     const props = jsx.useProps();
-    const { children, exclude, include, prefix = process.env.INNET_API_PREFIX || '', title = '', version = process.env.INNET_API_VERSION || '0.0.0', ...rest } = props;
+    const { children, errorShema, errorShemaRefs, exclude, include, prefix = process.env.INNET_API_PREFIX || '', schemaGeneration, title = '', version = process.env.INNET_API_VERSION || '0.0.0', ...rest } = props;
     const info = { ...rest, title, version };
     const endpoints = {};
     const docs = {
@@ -124,9 +124,7 @@ const api = () => {
                         if (!action.body) {
                             res.statusCode = 400;
                             res.setHeader('Content-Type', 'application/json');
-                            res.write(JSONString.JSONString({
-                                error: 'requestBodyContentType',
-                            }));
+                            res.write(JSONString.JSONString({ error: 'requestBodyContentType' }));
                             res.end();
                             return true;
                         }

package/plugins/main/body/body.es6.js

@@ -6,7 +6,7 @@ import '../../../utils/index.es6.js';
 import { endpointContext } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
 import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
 import { getOrAdd } from '../../../utils/getOrAdd/getOrAdd.es6.js';
-import { bodyFileContext } from '../../../hooks/useBodyFile/useBodyFile.es6.js';
+import { bodyContext } from '../../../hooks/useBodyContext/useBodyContext.es6.js';
 import { ruleContext } from '../../../hooks/useRule/useRule.es6.js';
 import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
 
@@ -33,13 +33,14 @@ const body = () => {
     schemaContext.set(handler, schema);
     const rules = getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
     let fileUsed = false;
-    bodyFileContext.set(handler, () => {
-        fileUsed = true;
+    bodyContext.set(handler, {
+        useFile: () => {
+            fileUsed = true;
+        },
     });
     ruleContext.set(handler, rule => {
         rules.body = rule;
     });
-    innet(children, handler);
     useEffect(() => {
         if (fileUsed) {
             requestBody.content['multipart/form-data'] = { schema };
@@ -50,6 +51,7 @@ const body = () => {
             }
         }
     });
+    innet(children, handler);
 };
 
 export { body };

package/plugins/main/body/body.js

@@ -10,7 +10,7 @@ require('../../../utils/index.js');
 var useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
 var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
 var getOrAdd = require('../../../utils/getOrAdd/getOrAdd.js');
-var useBodyFile = require('../../../hooks/useBodyFile/useBodyFile.js');
+var useBodyContext = require('../../../hooks/useBodyContext/useBodyContext.js');
 var useRule = require('../../../hooks/useRule/useRule.js');
 var useEffect = require('../../../hooks/useEffect/useEffect.js');
 
@@ -37,13 +37,14 @@ const body = () => {
     useSchemaContext.schemaContext.set(handler, schema);
     const rules = getOrAdd.getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
     let fileUsed = false;
-    useBodyFile.bodyFileContext.set(handler, () => {
-        fileUsed = true;
+    useBodyContext.bodyContext.set(handler, {
+        useFile: () => {
+            fileUsed = true;
+        },
     });
     useRule.ruleContext.set(handler, rule => {
         rules.body = rule;
     });
-    innet.innet(children, handler);
     useEffect.useEffect(() => {
         if (fileUsed) {
             requestBody.content['multipart/form-data'] = { schema };
@@ -54,6 +55,7 @@ const body = () => {
             }
         }
     });
+    innet.innet(children, handler);
 };
 
 exports.body = body;

package/plugins/main/endpoint/endpoint.d.ts

@@ -35,6 +35,8 @@ export interface EndpointProps {
      * That means the endpoint should not be described and will not be shown in the Open API documentation.
      * */
     private?: boolean;
+    /** It turns on auto-generation for schemas. */
+    schemaGeneration?: boolean;
     /**
      * An optional, string summary, intended to apply to all operations in this path.
      * */

package/plugins/main/endpoint/endpoint.es6.js

@@ -1,19 +1,55 @@
 import { useNewHandler, innet } from 'innet';
 import { useProps } from '@innet/jsx';
+import { defaultRequestValidationSchema, defaultRequestBodyContentTypeSchema } from '../../../constants.es6.js';
 import '../../../hooks/index.es6.js';
 import '../../../utils/index.es6.js';
 import { useTag } from '../../../hooks/useTag/useTag.es6.js';
 import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { getEndpoint } from '../../../utils/getEndpoint/getEndpoint.es6.js';
+import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
 import { endpointContext } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
 import { serverPlugins } from '../../../hooks/useServerPlugins/useServerPlugins.es6.js';
 
+function addErrorRequest(errorSchema, response) {
+    if (!response) {
+        return {
+            content: {
+                'application/json': {
+                    schema: errorSchema,
+                },
+            },
+        };
+    }
+    if (!('content' in response)) {
+        console.error('Cannot find content in response: ', response);
+        return response;
+    }
+    if (!('application/json' in response.content)) {
+        response.content['application/json'] = {
+            schema: errorSchema,
+        };
+        return response;
+    }
+    const schema = response.content['application/json'].schema;
+    if (!schema) {
+        response.content['application/json'].schema = errorSchema;
+        return response;
+    }
+    if ('oneOf' in schema) {
+        schema.oneOf.push(errorSchema);
+        return response;
+    }
+    response.content['application/json'].schema = {
+        oneOf: [schema, errorSchema],
+    };
+    return response;
+}
 const endpoint = () => {
     const handler = useNewHandler();
     const tag = useTag();
     const props = useProps();
-    const { docs, endpoints, } = useApi();
-    const { children, deprecated, description, method, operationId, path, private: privateMode, summary, } = props;
+    const { docs, endpoints, props: apiProps, } = useApi();
+    const { children, deprecated, description, method, operationId, path, private: privateMode, schemaGeneration = apiProps.schemaGeneration, summary, } = props;
     const { paths } = docs;
     if (!paths)
         throw Error('cannot find paths in docs');
@@ -46,6 +82,46 @@ const endpoint = () => {
         endpoints[method] = { key: '', plugins: new Set() };
     }
     const endpoint = getEndpoint(path, endpoints[method]);
+    if (schemaGeneration) {
+        useEffect(() => {
+            var _a, _b, _c, _d, _e;
+            if (operation.requestBody || ((_a = operation.parameters) === null || _a === void 0 ? void 0 : _a.length)) {
+                if (!operation.responses) {
+                    operation.responses = {};
+                }
+                if (!docs.components) {
+                    docs.components = {};
+                }
+                if (!docs.components.schemas) {
+                    docs.components.schemas = {};
+                }
+                const ref = (_c = (_b = apiProps.errorShemaRefs) === null || _b === void 0 ? void 0 : _b.requestValidation) !== null && _c !== void 0 ? _c : 'ApiValidationError';
+                if (!(ref in docs.components.schemas)) {
+                    docs.components.schemas[ref] = (_e = (_d = apiProps.errorShema) === null || _d === void 0 ? void 0 : _d.requestValidation) !== null && _e !== void 0 ? _e : defaultRequestValidationSchema;
+                }
+                operation.responses[400] = addErrorRequest({ $ref: `#/components/schemas/${ref}` }, operation.responses[400]);
+            }
+        });
+        useEffect(() => {
+            var _a, _b, _c, _d;
+            if (operation.requestBody) {
+                if (!operation.responses) {
+                    operation.responses = {};
+                }
+                if (!docs.components) {
+                    docs.components = {};
+                }
+                if (!docs.components.schemas) {
+                    docs.components.schemas = {};
+                }
+                const ref = (_b = (_a = apiProps.errorShemaRefs) === null || _a === void 0 ? void 0 : _a.requestValidation) !== null && _b !== void 0 ? _b : 'ApiRequestBodyContentTypeError';
+                if (!(ref in docs.components.schemas)) {
+                    docs.components.schemas[ref] = (_d = (_c = apiProps.errorShema) === null || _c === void 0 ? void 0 : _c.requestBodyContentType) !== null && _d !== void 0 ? _d : defaultRequestBodyContentTypeSchema;
+                }
+                operation.responses[400] = addErrorRequest({ $ref: `#/components/schemas/${ref}` }, operation.responses[400]);
+            }
+        });
+    }
     // @ts-expect-error: it's always an object
     endpointContext.set(handler, { endpoint, operation, props });
     // @ts-expect-error: it's always an object