@innet/server 1.7.0 → 2.0.0-alpha.0

package/plugins/request/proxy/proxy.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+var httpProxy = require('http-proxy');
+require('../../../hooks/index.js');
+var useRequest = require('../../../hooks/useRequest/useRequest.js');
+var useResponse = require('../../../hooks/useResponse/useResponse.js');
+var useThrow = require('../../../hooks/useThrow/useThrow.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var httpProxy__default = /*#__PURE__*/_interopDefaultLegacy(httpProxy);
+
+const proxy = () => {
+    const { to, secure } = jsx.useProps();
+    const req = useRequest.useRequest();
+    const res = useResponse.useResponse();
+    if (!req || !res) {
+        useThrow.useThrow('{type} MUST be in <request>');
+    }
+    const proxyServer = httpProxy__default["default"].createProxyServer({});
+    delete req.headers.host;
+    proxyServer.web(req, res, { target: to, secure });
+};
+
+exports.proxy = proxy;

package/plugins/{redirect → request/redirect}/index.d.ts

@@ -1 +1 @@
-export * from './redirect';
+export * from './redirect';

package/plugins/{redirect → request/redirect}/redirect.d.ts

@@ -1,19 +1,17 @@
-export declare const redirectStatuses: {
-    multipleChoices: number;
-    movedPermanently: number;
-    found: number;
-    seeOther: number;
-    notModified: number;
-    useProxy: number;
-    temporaryRedirect: number;
-    permanentRedirect: number;
-};
-export interface RedirectProps {
-    to: string;
-    encode?: boolean;
-    status?: number | keyof typeof redirectStatuses;
-}
-export declare function redirect({ props, children }: {
-    props: any;
-    children: any;
-}, handler: any): any;
+import { type HandlerPlugin } from 'innet';
+export declare const redirectStatuses: {
+    multipleChoices: number;
+    movedPermanently: number;
+    found: number;
+    seeOther: number;
+    notModified: number;
+    useProxy: number;
+    temporaryRedirect: number;
+    permanentRedirect: number;
+};
+export interface RedirectProps {
+    to: string;
+    encode?: boolean;
+    status?: number | keyof typeof redirectStatuses;
+}
+export declare const redirect: HandlerPlugin;

package/plugins/request/redirect/redirect.es6.js

@@ -0,0 +1,41 @@
+import { useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useResponse } from '../../../hooks/useResponse/useResponse.es6.js';
+import { useHeaders } from '../../../hooks/useHeaders/useHeaders.es6.js';
+
+const redirectStatuses = {
+    multipleChoices: 300,
+    movedPermanently: 301,
+    found: 302,
+    seeOther: 303,
+    notModified: 304,
+    useProxy: 305,
+    temporaryRedirect: 307,
+    permanentRedirect: 308,
+};
+function getStatus(status) {
+    if (typeof status === 'number')
+        return status;
+    // @ts-expect-error: FIXME
+    return redirectStatuses[status] || 301;
+}
+function customEncode(url) {
+    return encodeURI(url.replaceAll('%20', ' '));
+}
+const redirect = () => {
+    var _a;
+    const res = useResponse();
+    if (!res) {
+        throw Error('Use <redirect> inside <request>');
+    }
+    const headers = useHeaders();
+    const props = useProps();
+    const { to, status = 301, encode } = props;
+    res.writeHead(getStatus(status), {
+        location: encode ? customEncode(to) : to,
+        'Cache-Control': (_a = headers['Cache-Control']) !== null && _a !== void 0 ? _a : 'no-cache, no-store, must-revalidate',
+    });
+    res.end();
+};
+
+export { redirect, redirectStatuses };

package/plugins/request/redirect/redirect.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useResponse = require('../../../hooks/useResponse/useResponse.js');
+var useHeaders = require('../../../hooks/useHeaders/useHeaders.js');
+
+const redirectStatuses = {
+    multipleChoices: 300,
+    movedPermanently: 301,
+    found: 302,
+    seeOther: 303,
+    notModified: 304,
+    useProxy: 305,
+    temporaryRedirect: 307,
+    permanentRedirect: 308,
+};
+function getStatus(status) {
+    if (typeof status === 'number')
+        return status;
+    // @ts-expect-error: FIXME
+    return redirectStatuses[status] || 301;
+}
+function customEncode(url) {
+    return encodeURI(url.replaceAll('%20', ' '));
+}
+const redirect = () => {
+    var _a;
+    const res = useResponse.useResponse();
+    if (!res) {
+        throw Error('Use <redirect> inside <request>');
+    }
+    const headers = useHeaders.useHeaders();
+    const props = jsx.useProps();
+    const { to, status = 301, encode } = props;
+    res.writeHead(getStatus(status), {
+        location: encode ? customEncode(to) : to,
+        'Cache-Control': (_a = headers['Cache-Control']) !== null && _a !== void 0 ? _a : 'no-cache, no-store, must-revalidate',
+    });
+    res.end();
+};
+
+exports.redirect = redirect;
+exports.redirectStatuses = redirectStatuses;

package/plugins/{success → request/success}/index.d.ts

@@ -1 +1 @@
-export * from './success';
+export * from './success';

package/plugins/{success → request/success}/success.d.ts

@@ -1,19 +1,17 @@
-export declare const successStatuses: {
-    readonly ok: 200;
-    readonly created: 201;
-    readonly accepted: 202;
-    readonly outside: 203;
-    readonly noContent: 204;
-    readonly resetContent: 205;
-    readonly partialContent: 206;
-    readonly multiStatus: 207;
-    readonly alreadyReported: 208;
-};
-export declare type SuccessStatuses = keyof typeof successStatuses;
-export interface SuccessProps {
-    status?: SuccessStatuses | number;
-}
-export declare function success({ props, children }: {
-    props: any;
-    children: any;
-}, handler: any): any;
+import { type HandlerPlugin } from 'innet';
+export declare const successStatuses: {
+    readonly ok: 200;
+    readonly created: 201;
+    readonly accepted: 202;
+    readonly outside: 203;
+    readonly noContent: 204;
+    readonly resetContent: 205;
+    readonly partialContent: 206;
+    readonly multiStatus: 207;
+    readonly alreadyReported: 208;
+};
+export type SuccessStatuses = keyof typeof successStatuses;
+export interface SuccessProps {
+    status?: SuccessStatuses | number;
+}
+export declare const success: HandlerPlugin;

package/plugins/request/success/success.es6.js

@@ -0,0 +1,33 @@
+import { useChildren, useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useResponse } from '../../../hooks/useResponse/useResponse.es6.js';
+import { JSONString } from '../../../utils/JSONString/JSONString.es6.js';
+
+const successStatuses = {
+    ok: 200,
+    created: 201,
+    accepted: 202,
+    outside: 203,
+    noContent: 204,
+    resetContent: 205,
+    partialContent: 206,
+    multiStatus: 207,
+    alreadyReported: 208,
+};
+const success = () => {
+    const children = useChildren();
+    const props = useProps();
+    const res = useResponse();
+    const status = props === null || props === void 0 ? void 0 : props.status;
+    if (!res) {
+        throw Error('<success> MUST be in <request>');
+    }
+    res.statusCode = typeof status === 'string' ? successStatuses[status] : status !== null && status !== void 0 ? status : ((children) ? 200 : 204);
+    if (children) {
+        res.write(JSONString(children[0]));
+    }
+    res.end();
+};
+
+export { success, successStatuses };

package/plugins/request/success/success.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../utils/index.js');
+var useResponse = require('../../../hooks/useResponse/useResponse.js');
+var JSONString = require('../../../utils/JSONString/JSONString.js');
+
+const successStatuses = {
+    ok: 200,
+    created: 201,
+    accepted: 202,
+    outside: 203,
+    noContent: 204,
+    resetContent: 205,
+    partialContent: 206,
+    multiStatus: 207,
+    alreadyReported: 208,
+};
+const success = () => {
+    const children = jsx.useChildren();
+    const props = jsx.useProps();
+    const res = useResponse.useResponse();
+    const status = props === null || props === void 0 ? void 0 : props.status;
+    if (!res) {
+        throw Error('<success> MUST be in <request>');
+    }
+    res.statusCode = typeof status === 'string' ? successStatuses[status] : status !== null && status !== void 0 ? status : ((children) ? 200 : 204);
+    if (children) {
+        res.write(JSONString.JSONString(children[0]));
+    }
+    res.end();
+};
+
+exports.success = success;
+exports.successStatuses = successStatuses;

package/plugins/schema/array/array.d.ts

@@ -0,0 +1,5 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface ArrayProps extends BaseSchemaProps<any[]> {
+}
+export declare const array: HandlerPlugin;

package/plugins/schema/array/array.es6.js

@@ -0,0 +1,58 @@
+import innet, { useNewHandler } from 'innet';
+import { useContext, useProps, useChildren } from '@innet/jsx';
+import { callHandler } from '@innet/utils';
+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 { ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
+import { useParentRule, parentRuleContext } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { arrayOf } from '../../../utils/rules/arrayOf/arrayOf.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+
+const array = () => {
+    useBlock('path');
+    const setRule = useContext(ruleContext);
+    const handler = useNewHandler();
+    const props = useProps();
+    const schema = useSchemaType('array', props);
+    const children = useChildren();
+    const fieldSchema = {};
+    handler[schemaContext.key] = fieldSchema;
+    schema.items = fieldSchema;
+    if (setRule) {
+        let oneOfRulesMap;
+        const rules = [];
+        const parentRule = useParentRule();
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo(props.default));
+        }
+        const rootRule = (props === null || props === void 0 ? void 0 : props.default) === undefined
+            ? (rule) => parentRule(pipe(...rules, arrayOf(rule)))
+            : (rule) => pipe(...rules, arrayOf(rule));
+        parentRuleContext.reset(handler);
+        ruleContext.set(handler, rule => {
+            if (oneOfRulesMap) {
+                oneOfRulesMap.push(rule);
+            }
+            else {
+                oneOfRulesMap = [rule];
+                setRule(rootRule(oneOf(oneOfRulesMap)));
+            }
+        });
+        innet(children, handler);
+        innet(() => {
+            if (!oneOfRulesMap && setRule) {
+                setRule(rootRule(e => e));
+            }
+        }, callHandler);
+        return;
+    }
+    innet(children, handler);
+};
+
+export { array };

package/plugins/schema/array/array.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+var utils = require('@innet/utils');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+var arrayOf = require('../../../utils/rules/arrayOf/arrayOf.js');
+var oneOf = require('../../../utils/rules/oneOf/oneOf.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const array = () => {
+    useBlock.useBlock('path');
+    const setRule = jsx.useContext(useRule.ruleContext);
+    const handler = innet.useNewHandler();
+    const props = jsx.useProps();
+    const schema = useSchemaType.useSchemaType('array', props);
+    const children = jsx.useChildren();
+    const fieldSchema = {};
+    handler[useSchemaContext.schemaContext.key] = fieldSchema;
+    schema.items = fieldSchema;
+    if (setRule) {
+        let oneOfRulesMap;
+        const rules = [];
+        const parentRule = useParentRule.useParentRule();
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo.defaultTo(props.default));
+        }
+        const rootRule = (props === null || props === void 0 ? void 0 : props.default) === undefined
+            ? (rule) => parentRule(pipe.pipe(...rules, arrayOf.arrayOf(rule)))
+            : (rule) => pipe.pipe(...rules, arrayOf.arrayOf(rule));
+        useParentRule.parentRuleContext.reset(handler);
+        useRule.ruleContext.set(handler, rule => {
+            if (oneOfRulesMap) {
+                oneOfRulesMap.push(rule);
+            }
+            else {
+                oneOfRulesMap = [rule];
+                setRule(rootRule(oneOf.oneOf(oneOfRulesMap)));
+            }
+        });
+        innet__default["default"](children, handler);
+        innet__default["default"](() => {
+            if (!oneOfRulesMap && setRule) {
+                setRule(rootRule(e => e));
+            }
+        }, utils.callHandler);
+        return;
+    }
+    innet__default["default"](children, handler);
+};
+
+exports.array = array;

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

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

package/plugins/schema/array/index.es6.js

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

package/plugins/schema/array/index.js

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

package/plugins/schema/binary/binary.d.ts

@@ -0,0 +1,9 @@
+import { type HandlerPlugin } from 'innet';
+export interface BinaryProps {
+    ref?: string;
+    description?: string;
+    accept?: string;
+    min?: number;
+    max?: number;
+}
+export declare const binary: HandlerPlugin;

package/plugins/schema/binary/binary.es6.js

@@ -0,0 +1,39 @@
+import { useProps } 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 { useBodyFile } from '../../../hooks/useBodyFile/useBodyFile.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { bin } from '../../../utils/rules/bin/bin.es6.js';
+import { minBin } from '../../../utils/rules/minBin/minBin.es6.js';
+import { maxBin } from '../../../utils/rules/maxBin/maxBin.es6.js';
+import { binaryAccept } from '../../../utils/rules/binaryAccept/binaryAccept.es6.js';
+import { useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { useRule } from '../../../hooks/useRule/useRule.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+
+const binary = () => {
+    useBlock('path');
+    useBodyFile();
+    const props = useProps();
+    const schema = useSchemaType('string', props);
+    if (schema) {
+        schema.format = 'binary';
+    }
+    const rules = [];
+    rules.push(bin);
+    if (props === null || props === void 0 ? void 0 : props.min) {
+        rules.push(minBin(props.min));
+    }
+    if (props === null || props === void 0 ? void 0 : props.max) {
+        rules.push(maxBin(props.max));
+    }
+    if (props === null || props === void 0 ? void 0 : props.accept) {
+        rules.push(binaryAccept(props.accept));
+    }
+    const parentRule = useParentRule();
+    useRule(parentRule(pipe(...rules)));
+};
+
+export { binary };

package/plugins/schema/binary/binary.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useBodyFile = require('../../../hooks/useBodyFile/useBodyFile.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var bin = require('../../../utils/rules/bin/bin.js');
+var minBin = require('../../../utils/rules/minBin/minBin.js');
+var maxBin = require('../../../utils/rules/maxBin/maxBin.js');
+var binaryAccept = require('../../../utils/rules/binaryAccept/binaryAccept.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+
+const binary = () => {
+    useBlock.useBlock('path');
+    useBodyFile.useBodyFile();
+    const props = jsx.useProps();
+    const schema = useSchemaType.useSchemaType('string', props);
+    if (schema) {
+        schema.format = 'binary';
+    }
+    const rules = [];
+    rules.push(bin.bin);
+    if (props === null || props === void 0 ? void 0 : props.min) {
+        rules.push(minBin.minBin(props.min));
+    }
+    if (props === null || props === void 0 ? void 0 : props.max) {
+        rules.push(maxBin.maxBin(props.max));
+    }
+    if (props === null || props === void 0 ? void 0 : props.accept) {
+        rules.push(binaryAccept.binaryAccept(props.accept));
+    }
+    const parentRule = useParentRule.useParentRule();
+    useRule.useRule(parentRule(pipe.pipe(...rules)));
+};
+
+exports.binary = binary;

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

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

package/plugins/schema/binary/index.es6.js

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

package/plugins/{action → schema/binary}/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var action = require('./action.js');
+var binary = require('./binary.js');
 
 
 
-exports.action = action.action;
+exports.binary = binary.binary;

package/plugins/schema/boolean/boolean.d.ts

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

package/plugins/schema/boolean/boolean.es6.js

@@ -0,0 +1,32 @@
+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 { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { paramContext } from '../../../hooks/useParam/useParam.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { useRule } from '../../../hooks/useRule/useRule.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+
+const boolean = () => {
+    useBlock('path');
+    const props = useProps();
+    useSchemaType('boolean', props);
+    const param = useContext(paramContext);
+    const rules = [];
+    if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        rules.push(defaultTo(props.default));
+    }
+    rules.push(param ? val => val === 'true' || (val === 'false' ? false : Boolean(val)) : Boolean);
+    if ((props === null || props === void 0 ? void 0 : props.default) === undefined) {
+        const parentRule = useParentRule();
+        useRule(parentRule(pipe(...rules)));
+    }
+    else {
+        useRule(pipe(...rules));
+    }
+};
+
+export { boolean };

package/plugins/schema/boolean/boolean.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useParam = require('../../../hooks/useParam/useParam.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+
+const boolean = () => {
+    useBlock.useBlock('path');
+    const props = jsx.useProps();
+    useSchemaType.useSchemaType('boolean', props);
+    const param = jsx.useContext(useParam.paramContext);
+    const rules = [];
+    if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        rules.push(defaultTo.defaultTo(props.default));
+    }
+    rules.push(param ? val => val === 'true' || (val === 'false' ? false : Boolean(val)) : Boolean);
+    if ((props === null || props === void 0 ? void 0 : props.default) === undefined) {
+        const parentRule = useParentRule.useParentRule();
+        useRule.useRule(parentRule(pipe.pipe(...rules)));
+    }
+    else {
+        useRule.useRule(pipe.pipe(...rules));
+    }
+};
+
+exports.boolean = boolean;

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

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

package/plugins/schema/boolean/index.es6.js

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

package/plugins/schema/boolean/index.js

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

package/plugins/schema/date/date.d.ts

@@ -0,0 +1,8 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+import { type DateFormat } from '../../../utils';
+export interface DateProps extends ValuesSchemaProps<DateFormat> {
+    min?: DateFormat;
+    max?: DateFormat;
+}
+export declare const date: HandlerPlugin;