@innet/server 1.7.0 → 2.0.0-alpha.0

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

@@ -0,0 +1,54 @@
+import innet, { useNewHandler } from 'innet';
+import { useProps, useChildren } from '@innet/jsx';
+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 { endpointContext } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
+
+const endpoint = () => {
+    const handler = useNewHandler();
+    const tag = useTag();
+    const { docs, endpoints } = useApi();
+    const props = useProps();
+    const { path, summary, description, deprecated, method, private: privateMode } = props;
+    const children = useChildren();
+    const { paths } = docs;
+    if (!paths)
+        throw Error('cannot find paths in docs');
+    if (!paths[path]) {
+        paths[path] = {};
+    }
+    // @ts-expect-error: it's always an object
+    if (paths[path][method]) {
+        throw Error(`You cannot use the same endpoints ${method}:${path}`);
+    }
+    const operation = {};
+    if (summary) {
+        operation.summary = summary;
+    }
+    if (description) {
+        operation.description = description;
+    }
+    if (deprecated) {
+        operation.deprecated = deprecated;
+    }
+    if (tag) {
+        operation.tags = [tag.name];
+    }
+    if (!privateMode) {
+        // @ts-expect-error: it's always an object
+        paths[path][method] = operation;
+    }
+    if (!endpoints[method]) {
+        endpoints[method] = { key: '' };
+    }
+    // @ts-expect-error: it's always an object
+    const endpoint = getEndpoint(path, endpoints[method]);
+    // @ts-expect-error: it's always an object
+    endpointContext.set(handler, { operation, props, endpoint });
+    innet(children, handler);
+};
+
+export { endpoint };

package/plugins/main/endpoint/endpoint.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../utils/index.js');
+var useTag = require('../../../hooks/useTag/useTag.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+var getEndpoint = require('../../../utils/getEndpoint/getEndpoint.js');
+var useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const endpoint = () => {
+    const handler = innet.useNewHandler();
+    const tag = useTag.useTag();
+    const { docs, endpoints } = useApi.useApi();
+    const props = jsx.useProps();
+    const { path, summary, description, deprecated, method, private: privateMode } = props;
+    const children = jsx.useChildren();
+    const { paths } = docs;
+    if (!paths)
+        throw Error('cannot find paths in docs');
+    if (!paths[path]) {
+        paths[path] = {};
+    }
+    // @ts-expect-error: it's always an object
+    if (paths[path][method]) {
+        throw Error(`You cannot use the same endpoints ${method}:${path}`);
+    }
+    const operation = {};
+    if (summary) {
+        operation.summary = summary;
+    }
+    if (description) {
+        operation.description = description;
+    }
+    if (deprecated) {
+        operation.deprecated = deprecated;
+    }
+    if (tag) {
+        operation.tags = [tag.name];
+    }
+    if (!privateMode) {
+        // @ts-expect-error: it's always an object
+        paths[path][method] = operation;
+    }
+    if (!endpoints[method]) {
+        endpoints[method] = { key: '' };
+    }
+    // @ts-expect-error: it's always an object
+    const endpoint = getEndpoint.getEndpoint(path, endpoints[method]);
+    // @ts-expect-error: it's always an object
+    useEndpoint.endpointContext.set(handler, { operation, props, endpoint });
+    innet__default["default"](children, handler);
+};
+
+exports.endpoint = endpoint;

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

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

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

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

package/plugins/main/endpoint/index.js

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

package/plugins/main/fallback/fallback.d.ts

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

package/plugins/main/fallback/fallback.es6.js

@@ -0,0 +1,19 @@
+import { useHandler } from 'innet';
+import { useChildren } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+
+const fallback = () => {
+    const api = useApi();
+    if (!api) {
+        throw Error('Use <fallback> inside <api>');
+    }
+    if (api.fallback) {
+        throw Error('<fallback> MUST be used once on an <api>');
+    }
+    const children = useChildren();
+    const handler = useHandler();
+    api.fallback = { children, handler };
+};
+
+export { fallback };

package/plugins/main/fallback/fallback.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+
+const fallback = () => {
+    const api = useApi.useApi();
+    if (!api) {
+        throw Error('Use <fallback> inside <api>');
+    }
+    if (api.fallback) {
+        throw Error('<fallback> MUST be used once on an <api>');
+    }
+    const children = jsx.useChildren();
+    const handler = innet.useHandler();
+    api.fallback = { children, handler };
+};
+
+exports.fallback = fallback;

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

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

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

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

package/plugins/main/fallback/index.js

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

package/plugins/main/host/host.d.ts

@@ -0,0 +1,16 @@
+import { type HandlerPlugin } from 'innet';
+export interface HostProps {
+    /**
+     * A URL to the target host.
+     * This URL supports Server Variables and MAY be relative,
+     * to indicate that the host location is relative to the location where the OpenAPI document is being served.
+     * Variable substitutions will be made when a variable is named in {brackets}.
+     * */
+    url: string;
+    /**
+     * An optional string describing the host designated by the URL.
+     * [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text representation.
+     * */
+    description?: string;
+}
+export declare const host: HandlerPlugin;

package/plugins/main/host/host.es6.js

@@ -0,0 +1,26 @@
+import innet, { useNewHandler } from 'innet';
+import { useProps, useChildren, useContext } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+import { endpointContext } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
+import { hostContext } from '../../../hooks/useHost/useHost.es6.js';
+
+const host = () => {
+    const handler = useNewHandler();
+    const { docs } = useApi();
+    const props = useProps();
+    const children = useChildren();
+    const { operation } = useContext(endpointContext) || {};
+    const target = operation || docs;
+    if (!target.servers) {
+        target.servers = [];
+    }
+    const { servers } = operation || docs;
+    const server = Object.assign({}, props);
+    // @ts-expect-error: FIXME
+    servers.push(server);
+    handler[hostContext.key] = { server };
+    innet(children, handler);
+};
+
+export { host };

package/plugins/main/host/host.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+var useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
+var useHost = require('../../../hooks/useHost/useHost.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const host = () => {
+    const handler = innet.useNewHandler();
+    const { docs } = useApi.useApi();
+    const props = jsx.useProps();
+    const children = jsx.useChildren();
+    const { operation } = jsx.useContext(useEndpoint.endpointContext) || {};
+    const target = operation || docs;
+    if (!target.servers) {
+        target.servers = [];
+    }
+    const { servers } = operation || docs;
+    const server = Object.assign({}, props);
+    // @ts-expect-error: FIXME
+    servers.push(server);
+    handler[useHost.hostContext.key] = { server };
+    innet__default["default"](children, handler);
+};
+
+exports.host = host;

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

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

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

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

package/plugins/main/host/index.js

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

package/plugins/main/index.d.ts

@@ -0,0 +1,13 @@
+export * from './server';
+export * from './api';
+export * from './contact';
+export * from './license';
+export * from './host';
+export * from './variable';
+export * from './tag';
+export * from './endpoint';
+export * from './response';
+export * from './request';
+export * from './param';
+export * from './body';
+export * from './fallback';

package/plugins/main/index.es6.js

@@ -0,0 +1,13 @@
+import './server/index.es6.js';
+import './api/index.es6.js';
+import './contact/index.es6.js';
+import './license/index.es6.js';
+import './host/index.es6.js';
+import './variable/index.es6.js';
+import './tag/index.es6.js';
+import './endpoint/index.es6.js';
+import './response/index.es6.js';
+import './request/index.es6.js';
+import './param/index.es6.js';
+import './body/index.es6.js';
+import './fallback/index.es6.js';

package/plugins/main/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+require('./server/index.js');
+require('./api/index.js');
+require('./contact/index.js');
+require('./license/index.js');
+require('./host/index.js');
+require('./variable/index.js');
+require('./tag/index.js');
+require('./endpoint/index.js');
+require('./response/index.js');
+require('./request/index.js');
+require('./param/index.js');
+require('./body/index.js');
+require('./fallback/index.js');
+

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

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

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

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

package/plugins/main/license/index.js

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

package/plugins/main/license/license.d.ts

@@ -0,0 +1,21 @@
+import { type HandlerPlugin } from 'innet';
+export interface LicenseProps {
+    /**
+     * The license name used for the API.
+     * @example: Apache 2.0
+     * */
+    name: string;
+    /**
+     * An [SPDX](https://spdx.org/spdx-specification-21-web-version#h.jxpfx0ykyb60) license expression for the API.
+     * The `identifier` field is mutually exclusive of the `url` field.
+     * @example: Apache-2.0
+     * */
+    identifier?: string;
+    /**
+     * A URL to the license used for the API.
+     * This MUST be in the form of a URL.
+     * The `url` field is mutually exclusive of the `identifier` field.
+     * */
+    url?: string;
+}
+export declare const license: HandlerPlugin;

package/plugins/main/license/license.es6.js

@@ -0,0 +1,15 @@
+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 license = () => {
+    const { docs } = useApi();
+    const props = useProps();
+    if (docs.info.license) {
+        useOneElementError();
+    }
+    docs.info.license = props;
+};
+
+export { license };

package/plugins/main/license/license.js

@@ -0,0 +1,19 @@
+'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 license = () => {
+    const { docs } = useApi.useApi();
+    const props = jsx.useProps();
+    if (docs.info.license) {
+        useOneElementError.useOneElementError();
+    }
+    docs.info.license = props;
+};
+
+exports.license = license;

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

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

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

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

package/plugins/main/param/index.js

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

package/plugins/main/param/param.d.ts

@@ -0,0 +1,35 @@
+import { type HandlerPlugin } from 'innet';
+import { type InParam } from '../../../types';
+export interface ParamProps {
+    /**
+     * The location of the parameter.
+     * Possible values are "query", "header", "path" or "cookie".
+     * */
+    in: InParam;
+    /**
+     * The name of the parameter. Parameter names are *case sensitive*.
+     *
+     * - If `in` is "path", the `name` field MUST correspond to a template expression occurring within the `path` field in the `endpoint`. See [Path Templating](https://swagger.io/specification/#path-templating) for further information.
+     * - If `in` is "header" and the `name` field is "Accept", "Content-Type" or "Authorization", the parameter definition SHALL be ignored.
+     * - For all other cases, the `name` corresponds to the parameter name used by the `in` property.
+     * */
+    name: string;
+    /**
+     * A brief description of the parameter.
+     * This could contain examples of use.
+     * [CommonMark syntax](https://spec.commonmark.org) MAY be used for rich text representation.
+     * */
+    description?: string;
+    /**
+     * Determines whether this parameter is mandatory.
+     * If the parameter location is "path", this property is `true` and its value MUST be `true`.
+     * Otherwise, the property MAY be included and its default value is `false`.
+     * */
+    required?: boolean;
+    /**
+     * Specifies that a parameter is deprecated and SHOULD be transitioned out of usage.
+     * Default value is `false`.
+     * */
+    deprecated?: boolean;
+}
+export declare const param: HandlerPlugin;

package/plugins/main/param/param.es6.js

@@ -0,0 +1,63 @@
+import innet, { useNewHandler } from 'innet';
+import { useChildren, useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import '../../../utils/index.es6.js';
+import '../../../utils/rules/index.es6.js';
+import { useEndpoint } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
+import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
+import { getOrAdd } from '../../../utils/getOrAdd/getOrAdd.es6.js';
+import { objectOf } from '../../../utils/rules/objectOf/objectOf.es6.js';
+import { paramContext } from '../../../hooks/useParam/useParam.es6.js';
+import { ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+import { required } from '../../../utils/rules/required/required.es6.js';
+import { oneOf } from '../../../utils/rules/oneOf/oneOf.es6.js';
+
+const inMap = {
+    query: 'search',
+    path: 'path',
+    cookie: 'cookie',
+    header: 'header',
+};
+const param = () => {
+    var _a;
+    const { operation, endpoint } = useEndpoint();
+    if (!operation.parameters) {
+        operation.parameters = [];
+    }
+    const children = useChildren();
+    const props = useProps();
+    const params = Object.assign({}, props);
+    if (props.in === 'path') {
+        params.required = (_a = params.required) !== null && _a !== void 0 ? _a : true;
+    }
+    operation.parameters.push(params);
+    if (!children)
+        return;
+    const handler = useNewHandler();
+    const schema = {};
+    params.schema = schema;
+    schemaContext.set(handler, schema);
+    const rulesMap = getOrAdd(endpoint, `rulesMaps.${inMap[props.in]}`, [{}, {}]);
+    const oneOfRulesMap = {};
+    const key = props.name;
+    getOrAdd(endpoint, `rules.${inMap[props.in]}`, [{}, objectOf(rulesMap)]);
+    paramContext.set(handler, { props });
+    ruleContext.set(handler, rule => {
+        const override = params.required ? required : (e) => e;
+        if (key in rulesMap) {
+            if (key in oneOfRulesMap) {
+                oneOfRulesMap[key].push(rule);
+            }
+            else {
+                oneOfRulesMap[key] = [rulesMap[key], rule];
+                rulesMap[key] = override(oneOf(oneOfRulesMap[key]));
+            }
+        }
+        else {
+            rulesMap[key] = override(rule);
+        }
+    });
+    innet(children, handler);
+};
+
+export { param };

package/plugins/main/param/param.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../utils/index.js');
+require('../../../utils/rules/index.js');
+var useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
+var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
+var getOrAdd = require('../../../utils/getOrAdd/getOrAdd.js');
+var objectOf = require('../../../utils/rules/objectOf/objectOf.js');
+var useParam = require('../../../hooks/useParam/useParam.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var required = require('../../../utils/rules/required/required.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 inMap = {
+    query: 'search',
+    path: 'path',
+    cookie: 'cookie',
+    header: 'header',
+};
+const param = () => {
+    var _a;
+    const { operation, endpoint } = useEndpoint.useEndpoint();
+    if (!operation.parameters) {
+        operation.parameters = [];
+    }
+    const children = jsx.useChildren();
+    const props = jsx.useProps();
+    const params = Object.assign({}, props);
+    if (props.in === 'path') {
+        params.required = (_a = params.required) !== null && _a !== void 0 ? _a : true;
+    }
+    operation.parameters.push(params);
+    if (!children)
+        return;
+    const handler = innet.useNewHandler();
+    const schema = {};
+    params.schema = schema;
+    useSchemaContext.schemaContext.set(handler, schema);
+    const rulesMap = getOrAdd.getOrAdd(endpoint, `rulesMaps.${inMap[props.in]}`, [{}, {}]);
+    const oneOfRulesMap = {};
+    const key = props.name;
+    getOrAdd.getOrAdd(endpoint, `rules.${inMap[props.in]}`, [{}, objectOf.objectOf(rulesMap)]);
+    useParam.paramContext.set(handler, { props });
+    useRule.ruleContext.set(handler, rule => {
+        const override = params.required ? required.required : (e) => e;
+        if (key in rulesMap) {
+            if (key in oneOfRulesMap) {
+                oneOfRulesMap[key].push(rule);
+            }
+            else {
+                oneOfRulesMap[key] = [rulesMap[key], rule];
+                rulesMap[key] = override(oneOf.oneOf(oneOfRulesMap[key]));
+            }
+        }
+        else {
+            rulesMap[key] = override(rule);
+        }
+    });
+    innet__default["default"](children, handler);
+};
+
+exports.param = param;

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

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

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

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

package/plugins/main/request/index.js

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

package/plugins/main/request/request.d.ts

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

package/plugins/main/request/request.es6.js

@@ -0,0 +1,21 @@
+import { useHandler } from 'innet';
+import { useChildren } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useEndpoint } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
+
+const request = () => {
+    const endpointContext = useEndpoint();
+    if (!endpointContext) {
+        throw Error('Use <request> inside <endpoint>');
+    }
+    const children = useChildren();
+    const handler = useHandler();
+    const { endpoint, props } = endpointContext;
+    if (endpoint.content) {
+        throw Error(`You cannot use the same endpoints ${props.method}:${props.path}`);
+    }
+    endpoint.content = children;
+    endpoint.handler = handler;
+};
+
+export { request };