@innet/server 1.7.0 → 2.0.0-alpha.0

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

@@ -0,0 +1,180 @@
+import { __rest, __awaiter } from 'tslib';
+import innet, { useNewHandler, useApp } from 'innet';
+import { onDestroy } from 'watch-state';
+import '../../../hooks/index.es6.js';
+import '../../../utils/index.es6.js';
+import '../../../utils/rules/index.es6.js';
+import { useServer } from '../../../hooks/useServer/useServer.es6.js';
+import { apiContext } from '../../../hooks/useApi/useApi.es6.js';
+import { Action } from '../../../utils/action/Action.es6.js';
+import { JSONString } from '../../../utils/JSONString/JSONString.es6.js';
+import { RulesError } from '../../../utils/rules/helpers.es6.js';
+import { responseContext } from '../../../hooks/useResponse/useResponse.es6.js';
+import { requestContext } from '../../../hooks/useRequest/useRequest.es6.js';
+import { paramsContext } from '../../../hooks/useParams/useParams.es6.js';
+import { actionContext } from '../../../hooks/useAction/useAction.es6.js';
+
+const api = () => {
+    var _a;
+    const handler = useNewHandler();
+    const { props = {}, children } = useApp();
+    const { server } = useServer();
+    const { prefix = '', title = '' } = props, rest = __rest(props, ["prefix", "title"]);
+    const info = Object.assign(Object.assign({}, rest), { version: (_a = rest.version) !== null && _a !== void 0 ? _a : '0.0.0', title });
+    const endpoints = {};
+    const docs = {
+        openapi: '3.1.0',
+        info,
+        paths: {},
+    };
+    const requestPlugins = new Set();
+    const context = { docs, endpoints, prefix, requestPlugins, refRules: {} };
+    apiContext.set(handler, context);
+    const listener = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        var _b, _c, _d, _e, _f, _g;
+        if (res.writableEnded)
+            return;
+        const action = new Action(req);
+        const path = action.parsedUrl.path;
+        const url = path.endsWith('/') ? path.slice(0, -1) : path;
+        if (url === (prefix || '')) {
+            res.setHeader('Content-Type', 'application/json');
+            res.write(JSONString(docs));
+            res.end();
+            return;
+        }
+        if (!url.startsWith(prefix)) {
+            return;
+        }
+        const method = ((_c = (_b = req.method) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : 'get');
+        const rawSplitPath = url.slice(prefix.length).split('/').slice(1);
+        const splitPath = rawSplitPath.at(-1) ? rawSplitPath : rawSplitPath.slice(0, -1);
+        const endpoint = endpoints[method];
+        const endpointQueue = endpoint ? [[0, endpoint, {}]] : [];
+        while (endpointQueue.length > 0) {
+            const [deep, currentEndpoint, params] = endpointQueue.shift();
+            const key = splitPath[deep];
+            if (deep + 1 === splitPath.length) {
+                function run(runEndpoint, params) {
+                    var _a, _b, _c, _d, _e;
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const pathRules = (_a = runEndpoint.rules) === null || _a === void 0 ? void 0 : _a.path;
+                        const headerRules = (_b = runEndpoint.rules) === null || _b === void 0 ? void 0 : _b.header;
+                        const cookieRules = (_c = runEndpoint.rules) === null || _c === void 0 ? void 0 : _c.cookie;
+                        const searchRules = (_d = runEndpoint.rules) === null || _d === void 0 ? void 0 : _d.search;
+                        const bodyRules = (_e = runEndpoint.rules) === null || _e === void 0 ? void 0 : _e.body;
+                        if (pathRules) {
+                            try {
+                                Object.assign(params, pathRules(params, { in: 'path' }));
+                            }
+                            catch (_f) {
+                                return false;
+                            }
+                        }
+                        function checkActionRules(rules, key = 'search') {
+                            if (rules) {
+                                try {
+                                    action[key] = rules(action[key]);
+                                }
+                                catch (e) {
+                                    res.setHeader('Content-Type', 'application/json');
+                                    if (e instanceof RulesError) {
+                                        res.statusCode = 400;
+                                        res.write(JSONString({
+                                            error: 'requestValidation',
+                                            data: Object.assign(Object.assign({}, e.data), { in: key }),
+                                        }));
+                                        res.end();
+                                    }
+                                    else {
+                                        console.error(e);
+                                        res.statusCode = 500;
+                                        res.write(JSONString({
+                                            error: 'unknown',
+                                            data: { in: key },
+                                        }));
+                                        res.end();
+                                    }
+                                    return true;
+                                }
+                            }
+                            return false;
+                        }
+                        if (checkActionRules(headerRules, 'headers'))
+                            return true;
+                        if (checkActionRules(cookieRules, 'cookies'))
+                            return true;
+                        if (checkActionRules(searchRules, 'search'))
+                            return true;
+                        if (bodyRules) {
+                            yield action.parseBody();
+                            if (!action.body) {
+                                res.statusCode = 400;
+                                res.setHeader('Content-Type', 'application/json');
+                                res.write(JSONString({
+                                    error: 'requestBodyContentType',
+                                }));
+                                res.end();
+                                return true;
+                            }
+                            if (checkActionRules(bodyRules, 'body'))
+                                return true;
+                        }
+                        const newHandler = Object.create(runEndpoint.handler);
+                        responseContext.set(newHandler, res);
+                        requestContext.set(newHandler, req);
+                        paramsContext.set(newHandler, params);
+                        actionContext.set(newHandler, action);
+                        innet(runEndpoint.content, newHandler);
+                        return true;
+                    });
+                }
+                if ((_e = (_d = currentEndpoint.static) === null || _d === void 0 ? void 0 : _d[key]) === null || _e === void 0 ? void 0 : _e.content) {
+                    if (!(yield run((_f = currentEndpoint.static) === null || _f === void 0 ? void 0 : _f[key], params)))
+                        continue;
+                    return;
+                }
+                if (currentEndpoint.dynamic) {
+                    for (const dynamicEndpoint of currentEndpoint.dynamic) {
+                        if (dynamicEndpoint.content) {
+                            if (!(yield run(dynamicEndpoint, Object.assign(Object.assign({}, params), { [dynamicEndpoint.key.slice(1, -1)]: key }))))
+                                continue;
+                            return;
+                        }
+                    }
+                }
+                break;
+            }
+            if ((_g = currentEndpoint.static) === null || _g === void 0 ? void 0 : _g[key]) {
+                endpointQueue.push([deep + 1, currentEndpoint.static[key], params]);
+            }
+            if (currentEndpoint.dynamic) {
+                for (const dynamicEndpoint of currentEndpoint.dynamic) {
+                    endpointQueue.push([deep + 1, dynamicEndpoint, Object.assign(Object.assign({}, params), { [dynamicEndpoint.key.slice(1, -1)]: key })]);
+                }
+            }
+        }
+        for (const requestPlugin of requestPlugins) {
+            if (requestPlugin(req, res))
+                return;
+        }
+        if (context.fallback) {
+            const newHandler = Object.create(context.fallback.handler);
+            responseContext.set(newHandler, res);
+            requestContext.set(newHandler, req);
+            actionContext.set(newHandler, action);
+            innet(context.fallback.children, newHandler);
+        }
+        else {
+            res.statusCode = 404;
+            res.end();
+        }
+    });
+    server.on('request', listener);
+    onDestroy(() => {
+        server.off('request', listener);
+    });
+    innet(children, handler);
+};
+
+export { api };

package/plugins/main/api/api.js

@@ -0,0 +1,188 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var innet = require('innet');
+var watchState = require('watch-state');
+require('../../../hooks/index.js');
+require('../../../utils/index.js');
+require('../../../utils/rules/index.js');
+var useServer = require('../../../hooks/useServer/useServer.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+var Action = require('../../../utils/action/Action.js');
+var JSONString = require('../../../utils/JSONString/JSONString.js');
+var helpers = require('../../../utils/rules/helpers.js');
+var useResponse = require('../../../hooks/useResponse/useResponse.js');
+var useRequest = require('../../../hooks/useRequest/useRequest.js');
+var useParams = require('../../../hooks/useParams/useParams.js');
+var useAction = require('../../../hooks/useAction/useAction.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const api = () => {
+    var _a;
+    const handler = innet.useNewHandler();
+    const { props = {}, children } = innet.useApp();
+    const { server } = useServer.useServer();
+    const { prefix = '', title = '' } = props, rest = tslib.__rest(props, ["prefix", "title"]);
+    const info = Object.assign(Object.assign({}, rest), { version: (_a = rest.version) !== null && _a !== void 0 ? _a : '0.0.0', title });
+    const endpoints = {};
+    const docs = {
+        openapi: '3.1.0',
+        info,
+        paths: {},
+    };
+    const requestPlugins = new Set();
+    const context = { docs, endpoints, prefix, requestPlugins, refRules: {} };
+    useApi.apiContext.set(handler, context);
+    const listener = (req, res) => tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _b, _c, _d, _e, _f, _g;
+        if (res.writableEnded)
+            return;
+        const action = new Action.Action(req);
+        const path = action.parsedUrl.path;
+        const url = path.endsWith('/') ? path.slice(0, -1) : path;
+        if (url === (prefix || '')) {
+            res.setHeader('Content-Type', 'application/json');
+            res.write(JSONString.JSONString(docs));
+            res.end();
+            return;
+        }
+        if (!url.startsWith(prefix)) {
+            return;
+        }
+        const method = ((_c = (_b = req.method) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : 'get');
+        const rawSplitPath = url.slice(prefix.length).split('/').slice(1);
+        const splitPath = rawSplitPath.at(-1) ? rawSplitPath : rawSplitPath.slice(0, -1);
+        const endpoint = endpoints[method];
+        const endpointQueue = endpoint ? [[0, endpoint, {}]] : [];
+        while (endpointQueue.length > 0) {
+            const [deep, currentEndpoint, params] = endpointQueue.shift();
+            const key = splitPath[deep];
+            if (deep + 1 === splitPath.length) {
+                function run(runEndpoint, params) {
+                    var _a, _b, _c, _d, _e;
+                    return tslib.__awaiter(this, void 0, void 0, function* () {
+                        const pathRules = (_a = runEndpoint.rules) === null || _a === void 0 ? void 0 : _a.path;
+                        const headerRules = (_b = runEndpoint.rules) === null || _b === void 0 ? void 0 : _b.header;
+                        const cookieRules = (_c = runEndpoint.rules) === null || _c === void 0 ? void 0 : _c.cookie;
+                        const searchRules = (_d = runEndpoint.rules) === null || _d === void 0 ? void 0 : _d.search;
+                        const bodyRules = (_e = runEndpoint.rules) === null || _e === void 0 ? void 0 : _e.body;
+                        if (pathRules) {
+                            try {
+                                Object.assign(params, pathRules(params, { in: 'path' }));
+                            }
+                            catch (_f) {
+                                return false;
+                            }
+                        }
+                        function checkActionRules(rules, key = 'search') {
+                            if (rules) {
+                                try {
+                                    action[key] = rules(action[key]);
+                                }
+                                catch (e) {
+                                    res.setHeader('Content-Type', 'application/json');
+                                    if (e instanceof helpers.RulesError) {
+                                        res.statusCode = 400;
+                                        res.write(JSONString.JSONString({
+                                            error: 'requestValidation',
+                                            data: Object.assign(Object.assign({}, e.data), { in: key }),
+                                        }));
+                                        res.end();
+                                    }
+                                    else {
+                                        console.error(e);
+                                        res.statusCode = 500;
+                                        res.write(JSONString.JSONString({
+                                            error: 'unknown',
+                                            data: { in: key },
+                                        }));
+                                        res.end();
+                                    }
+                                    return true;
+                                }
+                            }
+                            return false;
+                        }
+                        if (checkActionRules(headerRules, 'headers'))
+                            return true;
+                        if (checkActionRules(cookieRules, 'cookies'))
+                            return true;
+                        if (checkActionRules(searchRules, 'search'))
+                            return true;
+                        if (bodyRules) {
+                            yield action.parseBody();
+                            if (!action.body) {
+                                res.statusCode = 400;
+                                res.setHeader('Content-Type', 'application/json');
+                                res.write(JSONString.JSONString({
+                                    error: 'requestBodyContentType',
+                                }));
+                                res.end();
+                                return true;
+                            }
+                            if (checkActionRules(bodyRules, 'body'))
+                                return true;
+                        }
+                        const newHandler = Object.create(runEndpoint.handler);
+                        useResponse.responseContext.set(newHandler, res);
+                        useRequest.requestContext.set(newHandler, req);
+                        useParams.paramsContext.set(newHandler, params);
+                        useAction.actionContext.set(newHandler, action);
+                        innet__default["default"](runEndpoint.content, newHandler);
+                        return true;
+                    });
+                }
+                if ((_e = (_d = currentEndpoint.static) === null || _d === void 0 ? void 0 : _d[key]) === null || _e === void 0 ? void 0 : _e.content) {
+                    if (!(yield run((_f = currentEndpoint.static) === null || _f === void 0 ? void 0 : _f[key], params)))
+                        continue;
+                    return;
+                }
+                if (currentEndpoint.dynamic) {
+                    for (const dynamicEndpoint of currentEndpoint.dynamic) {
+                        if (dynamicEndpoint.content) {
+                            if (!(yield run(dynamicEndpoint, Object.assign(Object.assign({}, params), { [dynamicEndpoint.key.slice(1, -1)]: key }))))
+                                continue;
+                            return;
+                        }
+                    }
+                }
+                break;
+            }
+            if ((_g = currentEndpoint.static) === null || _g === void 0 ? void 0 : _g[key]) {
+                endpointQueue.push([deep + 1, currentEndpoint.static[key], params]);
+            }
+            if (currentEndpoint.dynamic) {
+                for (const dynamicEndpoint of currentEndpoint.dynamic) {
+                    endpointQueue.push([deep + 1, dynamicEndpoint, Object.assign(Object.assign({}, params), { [dynamicEndpoint.key.slice(1, -1)]: key })]);
+                }
+            }
+        }
+        for (const requestPlugin of requestPlugins) {
+            if (requestPlugin(req, res))
+                return;
+        }
+        if (context.fallback) {
+            const newHandler = Object.create(context.fallback.handler);
+            useResponse.responseContext.set(newHandler, res);
+            useRequest.requestContext.set(newHandler, req);
+            useAction.actionContext.set(newHandler, action);
+            innet__default["default"](context.fallback.children, newHandler);
+        }
+        else {
+            res.statusCode = 404;
+            res.end();
+        }
+    });
+    server.on('request', listener);
+    watchState.onDestroy(() => {
+        server.off('request', listener);
+    });
+    innet__default["default"](children, handler);
+};
+
+exports.api = api;

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

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

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

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

package/plugins/main/api/index.js

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

package/plugins/main/body/body.d.ts

@@ -0,0 +1,4 @@
+import { type HandlerPlugin } from 'innet';
+export interface BodyProps {
+}
+export declare const body: HandlerPlugin;

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

@@ -0,0 +1,55 @@
+import innet, { useNewHandler } from 'innet';
+import { useContext, useChildren } from '@innet/jsx';
+import { callHandler } from '@innet/utils';
+import { allBodyTypes } from '../../../constants.es6.js';
+import '../../../hooks/index.es6.js';
+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 { ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+
+const body = () => {
+    const endpoint = useContext(endpointContext);
+    if (!endpoint) {
+        throw Error('<body> MUST be placed in <endpoint> element');
+    }
+    const children = useChildren();
+    const { operation } = endpoint;
+    if (!operation.requestBody) {
+        operation.requestBody = {
+            content: {},
+        };
+    }
+    const requestBody = operation.requestBody;
+    for (const type of allBodyTypes) {
+        if (requestBody.content[type]) {
+            throw Error(`<body type="${type}"> already used`);
+        }
+    }
+    const handler = useNewHandler();
+    const schema = {};
+    schemaContext.set(handler, schema);
+    const rules = getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
+    let fileUsed = false;
+    bodyFileContext.set(handler, () => {
+        fileUsed = true;
+    });
+    ruleContext.set(handler, rule => {
+        rules.body = rule;
+    });
+    innet(children, handler);
+    innet(() => {
+        if (fileUsed) {
+            requestBody.content['multipart/form-data'] = { schema };
+        }
+        else {
+            for (const type of allBodyTypes) {
+                requestBody.content[type] = { schema };
+            }
+        }
+    }, callHandler);
+};
+
+export { body };

package/plugins/main/body/body.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+var utils = require('@innet/utils');
+var constants = require('../../../constants.js');
+require('../../../hooks/index.js');
+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 useRule = require('../../../hooks/useRule/useRule.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const body = () => {
+    const endpoint = jsx.useContext(useEndpoint.endpointContext);
+    if (!endpoint) {
+        throw Error('<body> MUST be placed in <endpoint> element');
+    }
+    const children = jsx.useChildren();
+    const { operation } = endpoint;
+    if (!operation.requestBody) {
+        operation.requestBody = {
+            content: {},
+        };
+    }
+    const requestBody = operation.requestBody;
+    for (const type of constants.allBodyTypes) {
+        if (requestBody.content[type]) {
+            throw Error(`<body type="${type}"> already used`);
+        }
+    }
+    const handler = innet.useNewHandler();
+    const schema = {};
+    useSchemaContext.schemaContext.set(handler, schema);
+    const rules = getOrAdd.getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
+    let fileUsed = false;
+    useBodyFile.bodyFileContext.set(handler, () => {
+        fileUsed = true;
+    });
+    useRule.ruleContext.set(handler, rule => {
+        rules.body = rule;
+    });
+    innet__default["default"](children, handler);
+    innet__default["default"](() => {
+        if (fileUsed) {
+            requestBody.content['multipart/form-data'] = { schema };
+        }
+        else {
+            for (const type of constants.allBodyTypes) {
+                requestBody.content[type] = { schema };
+            }
+        }
+    }, utils.callHandler);
+};
+
+exports.body = body;

package/plugins/main/body/index.d.ts

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

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

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

package/plugins/main/body/index.js

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

package/plugins/main/contact/contact.d.ts

@@ -0,0 +1,10 @@
+import { type HandlerPlugin } from 'innet';
+export interface ContactProps {
+    /** The identifying name of the contact person/organization. */
+    name?: string;
+    /** The URL pointing to the contact information. This MUST be in the form of a URL. */
+    url?: string;
+    /** The email address of the contact person/organization. This MUST be in the form of an email address. */
+    email?: string;
+}
+export declare const contact: HandlerPlugin;

package/plugins/main/contact/contact.es6.js

@@ -0,0 +1,16 @@
+import { useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+import { useOneElementError } from '../../../hooks/useOneElementError/useOneElementError.es6.js';
+
+const contact = () => {
+    const { docs } = useApi();
+    const props = useProps();
+    const { contact } = docs.info;
+    if (contact) {
+        useOneElementError();
+    }
+    docs.info.contact = props;
+};
+
+export { contact };

package/plugins/main/contact/contact.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+var useOneElementError = require('../../../hooks/useOneElementError/useOneElementError.js');
+
+const contact = () => {
+    const { docs } = useApi.useApi();
+    const props = jsx.useProps();
+    const { contact } = docs.info;
+    if (contact) {
+        useOneElementError.useOneElementError();
+    }
+    docs.info.contact = props;
+};
+
+exports.contact = contact;

package/plugins/main/contact/index.d.ts

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

package/plugins/main/contact/index.es6.js

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

package/plugins/main/contact/index.js

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

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

@@ -0,0 +1,37 @@
+import { type HandlerPlugin } from 'innet';
+import { type EndpointsMethods } from '../../../types';
+export interface EndpointProps {
+    /**
+     * A method of the endpoint.
+     * */
+    method: EndpointsMethods;
+    /**
+     * A relative path to an individual endpoint.
+     * The property MUST begin with a forward slash (/).
+     * Path templating is allowed.
+     * When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts.
+     * Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical.
+     * */
+    path: string;
+    /**
+     * An optional, string summary, intended to apply to all operations in this path.
+     * */
+    summary?: string;
+    /**
+     * An optional, string description, intended to apply to all operations in this path.
+     * [CommonMark syntax](https://spec.commonmark.org) MAY be used for rich text representation.
+     * */
+    description?: string;
+    /**
+     * Declares this operation to be deprecated.
+     * Consumers SHOULD refrain from usage of the declared operation.
+     * Default value is false.
+     * */
+    deprecated?: boolean;
+    /**
+     * Declares this operation to make an endpoint private.
+     * That means the endpoint should not be described and will not be shown in the Open API documentation.
+     * */
+    private?: boolean;
+}
+export declare const endpoint: HandlerPlugin;