@innet/server 2.0.0-beta.26 → 2.0.0-beta.28

package/plugins/schema/object/object.es6.js

@@ -1,25 +1,30 @@
 import { useNewHandler, innet } from 'innet';
-import { useProps } from '@innet/jsx';
+import { useProps, useContext } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
 import '../../../utils/index.es6.js';
 import { useBlock } from '../../../hooks/useBlock/useBlock.es6.js';
+import { bodyContext } from '../../../hooks/useBodyContext/useBodyContext.es6.js';
 import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
 import { objectSchemaContext } from '../../../hooks/useObjectSchemaContext/useObjectSchemaContext.es6.js';
 import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
 import { parentRuleContext, useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
+import { getSafeSchema } from '../../../utils/getSafeSchema/getSafeSchema.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
 import { objectOf } from '../../../utils/rules/objectOf/objectOf.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+import { nullable } from '../../../utils/rules/nullable/nullable.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 import { useRule, ruleContext } from '../../../hooks/useRule/useRule.es6.js';
 import { objectRuleContext } from '../../../hooks/useObjectRule/useObjectRule.es6.js';
-import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
-import { getSafeSchema } from '../../../utils/getSafeSchema/getSafeSchema.es6.js';
 
 const object = () => {
     useBlock('path');
     const { children, ...props } = useProps();
+    const isBody = Boolean(useContext(bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const { refRules } = useApi();
     const schema = useSchemaType('object', props);
     const handler = useNewHandler();
@@ -28,39 +33,41 @@ const object = () => {
         objectSchemaContext.set(handler, schema);
         schemaContext.set(handler, schema.additionalProperties);
         parentRuleContext.reset(handler);
-        const rules = [];
-        const rulesMap = {};
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(defaultTo(props.default));
-        }
-        let childRule = v => v;
-        const restRule = (value, data) => childRule(value, data);
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf(rulesMap, restRule));
-        }
-        else {
-            const parentRule = useParentRule();
-            rules.push(parentRule(objectOf(rulesMap, restRule)));
-        }
-        const rule = pipe(...rules);
-        if (props.ref) {
-            refRules[props.ref] = rule;
-        }
-        useRule(rule);
-        objectRuleContext.set(handler, rulesMap);
-        ruleContext.set(handler, rule => {
-            childRule = rule;
-        });
-        parentRuleContext.reset(handler);
-        innet(children, handler);
         useEffect(() => {
             const safeSchema = getSafeSchema(schema);
             if (!Object.keys(safeSchema.additionalProperties).length) {
                 delete safeSchema.additionalProperties;
             }
         });
+        if (hasRules) {
+            const rules = [];
+            const rulesMap = {};
+            if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+                rules.push(defaultTo(props.default));
+            }
+            let childRule = v => v;
+            const restRule = (value, data) => childRule(value, data);
+            if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+                rules.push(objectOf(rulesMap, restRule));
+            }
+            else {
+                const parentRule = useParentRule();
+                rules.push(parentRule(objectOf(rulesMap, restRule)));
+            }
+            const rule = props.nullable ? oneOf([nullable, pipe(...rules)]) : pipe(...rules);
+            if (props.ref) {
+                refRules[props.ref] = rule;
+            }
+            useRule(rule);
+            objectRuleContext.set(handler, rulesMap);
+            ruleContext.set(handler, rule => {
+                childRule = rule;
+            });
+            parentRuleContext.reset(handler);
+        }
+        innet(children, handler);
     }
-    else if (props.ref) {
+    else if (props.ref && hasRules) {
         useRule(refRules[props.ref]);
     }
 };

package/plugins/schema/object/object.js

@@ -8,22 +8,27 @@ require('../../../hooks/index.js');
 require('../../../hooks/useParentRule/index.js');
 require('../../../utils/index.js');
 var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useBodyContext = require('../../../hooks/useBodyContext/useBodyContext.js');
 var useApi = require('../../../hooks/useApi/useApi.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
 var useObjectSchemaContext = require('../../../hooks/useObjectSchemaContext/useObjectSchemaContext.js');
 var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var useEffect = require('../../../hooks/useEffect/useEffect.js');
+var getSafeSchema = require('../../../utils/getSafeSchema/getSafeSchema.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
 var objectOf = require('../../../utils/rules/objectOf/objectOf.js');
+var oneOf = require('../../../utils/rules/oneOf/oneOf.js');
+var nullable = require('../../../utils/rules/nullable/nullable.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
 var useRule = require('../../../hooks/useRule/useRule.js');
 var useObjectRule = require('../../../hooks/useObjectRule/useObjectRule.js');
-var useEffect = require('../../../hooks/useEffect/useEffect.js');
-var getSafeSchema = require('../../../utils/getSafeSchema/getSafeSchema.js');
 
 const object = () => {
     useBlock.useBlock('path');
     const { children, ...props } = jsx.useProps();
+    const isBody = Boolean(jsx.useContext(useBodyContext.bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const { refRules } = useApi.useApi();
     const schema = useSchemaType.useSchemaType('object', props);
     const handler = innet.useNewHandler();
@@ -32,39 +37,41 @@ const object = () => {
         useObjectSchemaContext.objectSchemaContext.set(handler, schema);
         useSchemaContext.schemaContext.set(handler, schema.additionalProperties);
         useParentRule.parentRuleContext.reset(handler);
-        const rules = [];
-        const rulesMap = {};
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(defaultTo.defaultTo(props.default));
-        }
-        let childRule = v => v;
-        const restRule = (value, data) => childRule(value, data);
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf.objectOf(rulesMap, restRule));
-        }
-        else {
-            const parentRule = useParentRule.useParentRule();
-            rules.push(parentRule(objectOf.objectOf(rulesMap, restRule)));
-        }
-        const rule = pipe.pipe(...rules);
-        if (props.ref) {
-            refRules[props.ref] = rule;
-        }
-        useRule.useRule(rule);
-        useObjectRule.objectRuleContext.set(handler, rulesMap);
-        useRule.ruleContext.set(handler, rule => {
-            childRule = rule;
-        });
-        useParentRule.parentRuleContext.reset(handler);
-        innet.innet(children, handler);
         useEffect.useEffect(() => {
             const safeSchema = getSafeSchema.getSafeSchema(schema);
             if (!Object.keys(safeSchema.additionalProperties).length) {
                 delete safeSchema.additionalProperties;
             }
         });
+        if (hasRules) {
+            const rules = [];
+            const rulesMap = {};
+            if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+                rules.push(defaultTo.defaultTo(props.default));
+            }
+            let childRule = v => v;
+            const restRule = (value, data) => childRule(value, data);
+            if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+                rules.push(objectOf.objectOf(rulesMap, restRule));
+            }
+            else {
+                const parentRule = useParentRule.useParentRule();
+                rules.push(parentRule(objectOf.objectOf(rulesMap, restRule)));
+            }
+            const rule = props.nullable ? oneOf.oneOf([nullable.nullable, pipe.pipe(...rules)]) : pipe.pipe(...rules);
+            if (props.ref) {
+                refRules[props.ref] = rule;
+            }
+            useRule.useRule(rule);
+            useObjectRule.objectRuleContext.set(handler, rulesMap);
+            useRule.ruleContext.set(handler, rule => {
+                childRule = rule;
+            });
+            useParentRule.parentRuleContext.reset(handler);
+        }
+        innet.innet(children, handler);
     }
-    else if (props.ref) {
+    else if (props.ref && hasRules) {
         useRule.useRule(refRules[props.ref]);
     }
 };

package/plugins/schema/string/string.es6.js

@@ -1,14 +1,17 @@
-import { useProps } from '@innet/jsx';
+import { useProps, useContext } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
 import '../../../utils/index.es6.js';
 import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { bodyContext } from '../../../hooks/useBodyContext/useBodyContext.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
 import { values, getArrayValues } from '../../../utils/rules/values/values.es6.js';
 import { minLength } from '../../../utils/rules/minLength/minLength.es6.js';
 import { maxLength } from '../../../utils/rules/maxLength/maxLength.es6.js';
 import { pattern } from '../../../utils/rules/pattern/pattern.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+import { nullable } from '../../../utils/rules/nullable/nullable.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 import { useRule } from '../../../hooks/useRule/useRule.es6.js';
 import { useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
@@ -17,6 +20,8 @@ const string = () => {
     const { format, max, min, pattern: pattern$1, patternId, ...props } = useProps() || {};
     const { refRules } = useApi();
     const schema = useSchemaType('string', props);
+    const isBody = Boolean(useContext(bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     if (schema) {
         const rules = [];
         if (format !== undefined) {
@@ -44,7 +49,9 @@ const string = () => {
             schema.pattern = String(pattern$1);
             rules.push(pattern(pattern$1, patternId));
         }
-        const rule = pipe(...rules);
+        if (!hasRules)
+            return;
+        const rule = props.nullable ? oneOf([nullable, pipe(...rules)]) : pipe(...rules);
         if (props.ref) {
             refRules[props.ref] = rule;
         }
@@ -56,7 +63,7 @@ const string = () => {
             useRule(parentRule(rule));
         }
     }
-    else if (props.ref) {
+    else if (props.ref && hasRules) {
         if (props.default !== undefined) {
             useRule(refRules[props.ref]);
         }

package/plugins/schema/string/string.js

@@ -8,11 +8,14 @@ require('../../../hooks/useParentRule/index.js');
 require('../../../utils/index.js');
 var useApi = require('../../../hooks/useApi/useApi.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useBodyContext = require('../../../hooks/useBodyContext/useBodyContext.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
 var values = require('../../../utils/rules/values/values.js');
 var minLength = require('../../../utils/rules/minLength/minLength.js');
 var maxLength = require('../../../utils/rules/maxLength/maxLength.js');
 var pattern = require('../../../utils/rules/pattern/pattern.js');
+var oneOf = require('../../../utils/rules/oneOf/oneOf.js');
+var nullable = require('../../../utils/rules/nullable/nullable.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
 var useRule = require('../../../hooks/useRule/useRule.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
@@ -21,6 +24,8 @@ const string = () => {
     const { format, max, min, pattern: pattern$1, patternId, ...props } = jsx.useProps() || {};
     const { refRules } = useApi.useApi();
     const schema = useSchemaType.useSchemaType('string', props);
+    const isBody = Boolean(jsx.useContext(useBodyContext.bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     if (schema) {
         const rules = [];
         if (format !== undefined) {
@@ -48,7 +53,9 @@ const string = () => {
             schema.pattern = String(pattern$1);
             rules.push(pattern.pattern(pattern$1, patternId));
         }
-        const rule = pipe.pipe(...rules);
+        if (!hasRules)
+            return;
+        const rule = props.nullable ? oneOf.oneOf([nullable.nullable, pipe.pipe(...rules)]) : pipe.pipe(...rules);
         if (props.ref) {
             refRules[props.ref] = rule;
         }
@@ -60,7 +67,7 @@ const string = () => {
             useRule.useRule(parentRule(rule));
         }
     }
-    else if (props.ref) {
+    else if (props.ref && hasRules) {
         if (props.default !== undefined) {
             useRule.useRule(refRules[props.ref]);
         }

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

@@ -1,16 +1,19 @@
 import { useNewHandler, innet } from 'innet';
-import { useProps } from '@innet/jsx';
+import { useProps, useContext } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
 import '../../../utils/index.es6.js';
 import { useBlock } from '../../../hooks/useBlock/useBlock.es6.js';
+import { bodyContext } from '../../../hooks/useBodyContext/useBodyContext.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
 import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
 import { tupleOf } from '../../../utils/rules/tupleOf/tupleOf.es6.js';
 import { useParentRule, parentRuleContext } from '../../../hooks/useParentRule/useParentRule.es6.js';
-import { useRule, ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+import { nullable } from '../../../utils/rules/nullable/nullable.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { useRule, ruleContext } from '../../../hooks/useRule/useRule.es6.js';
 import { required } from '../../../utils/rules/required/required.es6.js';
 import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
 
@@ -18,35 +21,38 @@ const tuple = () => {
     useBlock('path');
     const handler = useNewHandler();
     const { children, ...props } = useProps();
+    const isBody = Boolean(useContext(bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const schema = useSchemaType('array', props);
     if (schema) {
         const schemas = [];
         handler[schemaContext.key] = schemas;
         // @ts-expect-error: FIXME
         schema.prefixItems = schemas;
-        const rulesMap = [];
-        const rules = [];
-        if (props.default !== undefined) {
-            rules.push(defaultTo(props.default));
-        }
-        if (props.default !== undefined) {
-            rules.push(tupleOf(rulesMap));
-        }
-        else {
-            const parentRule = useParentRule();
-            rules.push(parentRule(tupleOf(rulesMap)));
+        if (hasRules) {
+            const rulesMap = [];
+            const rules = [];
+            if (props.default !== undefined) {
+                rules.push(defaultTo(props.default));
+                rules.push(tupleOf(rulesMap));
+            }
+            else {
+                const parentRule = useParentRule();
+                rules.push(parentRule(tupleOf(rulesMap)));
+            }
+            const rule = props.nullable ? oneOf([nullable, pipe(...rules)]) : pipe(...rules);
+            useRule(rule);
+            parentRuleContext.set(handler, rule => required(rule));
+            ruleContext.set(handler, rule => {
+                rulesMap.push(rule);
+            });
+            useEffect(() => {
+                if (!rulesMap.length) {
+                    throw Error('<tuple> MUST have content');
+                }
+            });
         }
-        useRule(pipe(...rules));
-        parentRuleContext.set(handler, rule => required(rule));
-        ruleContext.set(handler, rule => {
-            rulesMap.push(rule);
-        });
         innet(children, handler);
-        useEffect(() => {
-            if (!rulesMap.length) {
-                throw Error('<tuple> MUST have content');
-            }
-        });
     }
 };
 

package/plugins/schema/tuple/tuple.js

@@ -8,13 +8,16 @@ require('../../../hooks/index.js');
 require('../../../hooks/useParentRule/index.js');
 require('../../../utils/index.js');
 var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useBodyContext = require('../../../hooks/useBodyContext/useBodyContext.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
 var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
 var tupleOf = require('../../../utils/rules/tupleOf/tupleOf.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
-var useRule = require('../../../hooks/useRule/useRule.js');
+var oneOf = require('../../../utils/rules/oneOf/oneOf.js');
+var nullable = require('../../../utils/rules/nullable/nullable.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
 var required = require('../../../utils/rules/required/required.js');
 var useEffect = require('../../../hooks/useEffect/useEffect.js');
 
@@ -22,35 +25,38 @@ const tuple = () => {
     useBlock.useBlock('path');
     const handler = innet.useNewHandler();
     const { children, ...props } = jsx.useProps();
+    const isBody = Boolean(jsx.useContext(useBodyContext.bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const schema = useSchemaType.useSchemaType('array', props);
     if (schema) {
         const schemas = [];
         handler[useSchemaContext.schemaContext.key] = schemas;
         // @ts-expect-error: FIXME
         schema.prefixItems = schemas;
-        const rulesMap = [];
-        const rules = [];
-        if (props.default !== undefined) {
-            rules.push(defaultTo.defaultTo(props.default));
-        }
-        if (props.default !== undefined) {
-            rules.push(tupleOf.tupleOf(rulesMap));
-        }
-        else {
-            const parentRule = useParentRule.useParentRule();
-            rules.push(parentRule(tupleOf.tupleOf(rulesMap)));
+        if (hasRules) {
+            const rulesMap = [];
+            const rules = [];
+            if (props.default !== undefined) {
+                rules.push(defaultTo.defaultTo(props.default));
+                rules.push(tupleOf.tupleOf(rulesMap));
+            }
+            else {
+                const parentRule = useParentRule.useParentRule();
+                rules.push(parentRule(tupleOf.tupleOf(rulesMap)));
+            }
+            const rule = props.nullable ? oneOf.oneOf([nullable.nullable, pipe.pipe(...rules)]) : pipe.pipe(...rules);
+            useRule.useRule(rule);
+            useParentRule.parentRuleContext.set(handler, rule => required.required(rule));
+            useRule.ruleContext.set(handler, rule => {
+                rulesMap.push(rule);
+            });
+            useEffect.useEffect(() => {
+                if (!rulesMap.length) {
+                    throw Error('<tuple> MUST have content');
+                }
+            });
         }
-        useRule.useRule(pipe.pipe(...rules));
-        useParentRule.parentRuleContext.set(handler, rule => required.required(rule));
-        useRule.ruleContext.set(handler, rule => {
-            rulesMap.push(rule);
-        });
         innet.innet(children, handler);
-        useEffect.useEffect(() => {
-            if (!rulesMap.length) {
-                throw Error('<tuple> MUST have content');
-            }
-        });
     }
 };
 

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

@@ -1,17 +1,22 @@
-import { useProps } from '@innet/jsx';
+import { useProps, useContext } from '@innet/jsx';
 import { v4 } from 'uuid';
 import '../../../hooks/index.es6.js';
 import '../../../utils/index.es6.js';
+import { bodyContext } from '../../../hooks/useBodyContext/useBodyContext.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
 import { uuidTo } from '../../../utils/rules/uuidTo/uuidTo.es6.js';
 import { values, getArrayValues } from '../../../utils/rules/values/values.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+import { nullable } from '../../../utils/rules/nullable/nullable.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 import { useRule } from '../../../hooks/useRule/useRule.es6.js';
 import { optional } from '../../../utils/rules/optional/optional.es6.js';
-import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 
 const uuid = () => {
     const { default: defaultValue, ...props } = useProps();
+    const isBody = Boolean(useContext(bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const params = {
         ...props,
     };
@@ -25,6 +30,8 @@ const uuid = () => {
         // @ts-expect-error: FIXME
         schema['x-default'] = defaultValue;
     }
+    if (!hasRules)
+        return;
     const rules = [];
     if (defaultValue !== undefined) {
         rules.push(defaultTo(defaultValue === 'new' ? v4 : defaultValue));
@@ -33,11 +40,12 @@ const uuid = () => {
     if (props.values) {
         rules.push(values(getArrayValues(props.values)));
     }
+    const rule = props.nullable ? oneOf([nullable, pipe(...rules)]) : pipe(...rules);
     if (defaultValue === undefined) {
-        useRule(optional(pipe(...rules)));
+        useRule(optional(rule));
     }
     else {
-        useRule(pipe(...rules));
+        useRule(rule);
     }
 };
 

package/plugins/schema/uuid/uuid.js

@@ -6,16 +6,21 @@ var jsx = require('@innet/jsx');
 var uuid$1 = require('uuid');
 require('../../../hooks/index.js');
 require('../../../utils/index.js');
+var useBodyContext = require('../../../hooks/useBodyContext/useBodyContext.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
 var uuidTo = require('../../../utils/rules/uuidTo/uuidTo.js');
 var values = require('../../../utils/rules/values/values.js');
+var oneOf = require('../../../utils/rules/oneOf/oneOf.js');
+var nullable = require('../../../utils/rules/nullable/nullable.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
 var useRule = require('../../../hooks/useRule/useRule.js');
 var optional = require('../../../utils/rules/optional/optional.js');
-var pipe = require('../../../utils/rules/pipe/pipe.js');
 
 const uuid = () => {
     const { default: defaultValue, ...props } = jsx.useProps();
+    const isBody = Boolean(jsx.useContext(useBodyContext.bodyContext));
+    const hasRules = !isBody || !props.readOnly;
     const params = {
         ...props,
     };
@@ -29,6 +34,8 @@ const uuid = () => {
         // @ts-expect-error: FIXME
         schema['x-default'] = defaultValue;
     }
+    if (!hasRules)
+        return;
     const rules = [];
     if (defaultValue !== undefined) {
         rules.push(defaultTo.defaultTo(defaultValue === 'new' ? uuid$1.v4 : defaultValue));
@@ -37,11 +44,12 @@ const uuid = () => {
     if (props.values) {
         rules.push(values.values(values.getArrayValues(props.values)));
     }
+    const rule = props.nullable ? oneOf.oneOf([nullable.nullable, pipe.pipe(...rules)]) : pipe.pipe(...rules);
     if (defaultValue === undefined) {
-        useRule.useRule(optional.optional(pipe.pipe(...rules)));
+        useRule.useRule(optional.optional(rule));
     }
     else {
-        useRule.useRule(pipe.pipe(...rules));
+        useRule.useRule(rule);
     }
 };
 

package/types/appTypes.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAPIV3_1 as API } from 'openapi-types';
+import type { OpenAPIV3_1 as API, OpenAPIV3_1 } from 'openapi-types';
 import type { ApiErrorValue } from '../constants';
 import { type ServerPlugin } from '../hooks';
 import { type ResponseStatus } from '../plugins';
@@ -58,6 +58,8 @@ export interface ServerStartParams {
     https: boolean;
     port: number;
 }
+export type ApiErrorSchema = Record<ApiErrorValue, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.SchemaObject>;
+export type ApiErrorSchemaRefs = Record<ApiErrorValue, string>;
 export type SchemaValues<T> = (T extends (number | string) ? Record<T, string> : never) | T[];
 export interface BaseSchemaProps<T, D = T> {
     default?: D;

package/utils/rules/constants.d.ts

@@ -1 +1,5 @@
+import type { OpenAPIV3_1 } from 'openapi-types';
+import { type RulesErrors } from './types';
+export declare const inValidationValues: ["body", "query", "cookie", "header", "path"];
 export declare const rulesErrors: readonly ["oneOf", "number", "date", "uuid", "integer", "minimum", "boolean", "minDate", "maxDate", "maximum", "minLength", "maxLength", "values", "object", "array", "tuple", "required", "null", "pattern", "string", "binary", "binaryAccept", "minBin", "maxBin"];
+export declare const rulesErrorSchemas: Record<RulesErrors, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.SchemaObject>;