@innet/server 1.7.0 → 2.0.0-alpha.0

package/plugins/main/request/request.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
+
+const request = () => {
+    const endpointContext = useEndpoint.useEndpoint();
+    if (!endpointContext) {
+        throw Error('Use <request> inside <endpoint>');
+    }
+    const children = jsx.useChildren();
+    const handler = innet.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;
+};
+
+exports.request = request;

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

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

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

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

package/plugins/main/response/index.js

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

package/plugins/main/response/response.d.ts

@@ -0,0 +1,16 @@
+import { type HandlerPlugin } from 'innet';
+export interface ResponseProps {
+    /**
+     * A description of the response.
+     * [CommonMark syntax](https://spec.commonmark.org) MAY be used for rich text representation.
+     * */
+    description: string;
+    /**
+     * Any [HTTP status code](https://swagger.io/specification/#http-codes) can be used as the property.
+     * To define a range of response codes, this field MAY contain the uppercase wildcard character X.
+     * For example, 2XX represents all response codes between [200-299].
+     * Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX.
+     * */
+    status?: number | 'default';
+}
+export declare const response: HandlerPlugin;

package/plugins/main/response/response.es6.js

@@ -0,0 +1,44 @@
+import innet, { useNewHandler } from 'innet';
+import { useProps, useChildren, useContext } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useEndpoint, endpointContext } from '../../../hooks/useEndpoint/useEndpoint.es6.js';
+import { useThrow } from '../../../hooks/useThrow/useThrow.es6.js';
+import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
+import { getOrAdd } from '../../../utils/getOrAdd/getOrAdd.es6.js';
+import { ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+
+const response = () => {
+    const { description, status = 'default' } = useProps();
+    const { operation, props: { path } } = useEndpoint();
+    const children = useChildren();
+    const handler = useNewHandler();
+    const endpoint = useContext(endpointContext);
+    if (!endpoint) {
+        useThrow('<{type}> MUST be placed in <endpoint> element');
+    }
+    if (!operation.responses) {
+        operation.responses = {};
+    }
+    if (operation.responses[status]) {
+        throw Error(`status ${status} for '${path}' already used`);
+    }
+    const schema = {};
+    const response = {
+        description,
+        content: {
+            'application/json': {
+                schema,
+            },
+        },
+    };
+    operation.responses[status] = response;
+    schemaContext.set(handler, schema);
+    const rules = getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
+    ruleContext.set(handler, rule => {
+        rules.response = rule;
+    });
+    innet(children, handler);
+};
+
+export { response };

package/plugins/main/response/response.js

@@ -0,0 +1,52 @@
+'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 useEndpoint = require('../../../hooks/useEndpoint/useEndpoint.js');
+var useThrow = require('../../../hooks/useThrow/useThrow.js');
+var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
+var getOrAdd = require('../../../utils/getOrAdd/getOrAdd.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 response = () => {
+    const { description, status = 'default' } = jsx.useProps();
+    const { operation, props: { path } } = useEndpoint.useEndpoint();
+    const children = jsx.useChildren();
+    const handler = innet.useNewHandler();
+    const endpoint = jsx.useContext(useEndpoint.endpointContext);
+    if (!endpoint) {
+        useThrow.useThrow('<{type}> MUST be placed in <endpoint> element');
+    }
+    if (!operation.responses) {
+        operation.responses = {};
+    }
+    if (operation.responses[status]) {
+        throw Error(`status ${status} for '${path}' already used`);
+    }
+    const schema = {};
+    const response = {
+        description,
+        content: {
+            'application/json': {
+                schema,
+            },
+        },
+    };
+    operation.responses[status] = response;
+    useSchemaContext.schemaContext.set(handler, schema);
+    const rules = getOrAdd.getOrAdd(endpoint, 'endpoint.rules', [{}, {}]);
+    useRule.ruleContext.set(handler, rule => {
+        rules.response = rule;
+    });
+    innet__default["default"](children, handler);
+};
+
+exports.response = response;

package/plugins/{server → main/server}/index.d.ts

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

package/plugins/main/server/server.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { type HandlerPlugin } from 'innet';
+import { type ServerResponse } from 'http';
+import { type ServerStartParams, type SSL } from '../../../types';
+export interface ServerProps {
+    port?: number;
+    ssl?: SSL;
+    onStart?: (params: ServerStartParams) => any;
+    onRequest?: (req: Request, res: ServerResponse) => any;
+    onError?: (e: Error) => any;
+    onDestroy?: () => any;
+}
+export declare const server: HandlerPlugin;

package/plugins/main/server/server.es6.js

@@ -0,0 +1,44 @@
+import innet, { useNewHandler, useApp } from 'innet';
+import fs from 'node:fs';
+import http from 'node:http';
+import http2 from 'node:https';
+import { onDestroy } from 'watch-state';
+import '../../../hooks/index.es6.js';
+import { serverContext } from '../../../hooks/useServer/useServer.es6.js';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const isInvalidPath = require('is-invalid-path');
+const server = () => {
+    var _a, _b, _c;
+    const handler = useNewHandler();
+    const { props = {}, children } = useApp();
+    const { env } = process;
+    let { ssl: { key = (_a = env.SSL_KEY) !== null && _a !== void 0 ? _a : 'localhost.key', cert = (_b = env.SSL_CRT) !== null && _b !== void 0 ? _b : 'localhost.crt', } = {}, } = props;
+    if (!isInvalidPath(key)) {
+        key = fs.readFileSync(key).toString();
+    }
+    if (!isInvalidPath(cert)) {
+        cert = fs.readFileSync(cert).toString();
+    }
+    const https = Boolean(key && cert);
+    const { port = Number((_c = env.PORT) !== null && _c !== void 0 ? _c : (https ? 442 : 80)), onStart, onError, onRequest, } = props;
+    const server = https ? http2.createServer({ key, cert }) : http.createServer();
+    handler[serverContext.key] = { server, port };
+    onDestroy(() => {
+        var _a;
+        (_a = props.onDestroy) === null || _a === void 0 ? void 0 : _a.call(props);
+        server.close();
+    });
+    if (onError) {
+        server.on('error', onError);
+    }
+    if (onRequest) {
+        server.on('request', onRequest);
+    }
+    innet(children, handler);
+    server.listen(port, () => {
+        onStart === null || onStart === void 0 ? void 0 : onStart({ port, https });
+    });
+};
+
+export { server };

package/plugins/main/server/server.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var fs = require('node:fs');
+var http = require('node:http');
+var http2 = require('node:https');
+var watchState = require('watch-state');
+require('../../../hooks/index.js');
+var useServer = require('../../../hooks/useServer/useServer.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var http2__default = /*#__PURE__*/_interopDefaultLegacy(http2);
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const isInvalidPath = require('is-invalid-path');
+const server = () => {
+    var _a, _b, _c;
+    const handler = innet.useNewHandler();
+    const { props = {}, children } = innet.useApp();
+    const { env } = process;
+    let { ssl: { key = (_a = env.SSL_KEY) !== null && _a !== void 0 ? _a : 'localhost.key', cert = (_b = env.SSL_CRT) !== null && _b !== void 0 ? _b : 'localhost.crt', } = {}, } = props;
+    if (!isInvalidPath(key)) {
+        key = fs__default["default"].readFileSync(key).toString();
+    }
+    if (!isInvalidPath(cert)) {
+        cert = fs__default["default"].readFileSync(cert).toString();
+    }
+    const https = Boolean(key && cert);
+    const { port = Number((_c = env.PORT) !== null && _c !== void 0 ? _c : (https ? 442 : 80)), onStart, onError, onRequest, } = props;
+    const server = https ? http2__default["default"].createServer({ key, cert }) : http__default["default"].createServer();
+    handler[useServer.serverContext.key] = { server, port };
+    watchState.onDestroy(() => {
+        var _a;
+        (_a = props.onDestroy) === null || _a === void 0 ? void 0 : _a.call(props);
+        server.close();
+    });
+    if (onError) {
+        server.on('error', onError);
+    }
+    if (onRequest) {
+        server.on('request', onRequest);
+    }
+    innet__default["default"](children, handler);
+    server.listen(port, () => {
+        onStart === null || onStart === void 0 ? void 0 : onStart({ port, https });
+    });
+};
+
+exports.server = server;

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

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

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

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

package/plugins/main/tag/index.js

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

package/plugins/main/tag/tag.d.ts

@@ -0,0 +1,11 @@
+import { type HandlerPlugin } from 'innet';
+export interface TagProps {
+    /** The name of the tag. */
+    name: string;
+    /**
+     * A description for the tag.
+     * [CommonMark syntax](https://spec.commonmark.org) MAY be used for rich text representation.
+     * */
+    description?: string;
+}
+export declare const tag: HandlerPlugin;

package/plugins/main/tag/tag.es6.js

@@ -0,0 +1,29 @@
+import innet, { useNewHandler } from 'innet';
+import { useContext, useProps, useChildren } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { tagContext } from '../../../hooks/useTag/useTag.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+
+const tag = () => {
+    if (useContext(tagContext)) {
+        throw Error('You cannot use a <tag> inside another one');
+    }
+    const { name, description } = useProps();
+    const children = useChildren();
+    const { docs } = useApi();
+    const tag = description ? { name, description } : { name };
+    if (!docs.tags) {
+        docs.tags = [tag];
+    }
+    else if (!docs.tags.find(({ name: tagName }) => tagName === name)) {
+        docs.tags.push(tag);
+    }
+    else {
+        throw Error(`You cannot use two tags with the same name (${name})`);
+    }
+    const handler = useNewHandler();
+    handler[tagContext.key] = tag;
+    innet(children, handler);
+};
+
+export { tag };

package/plugins/main/tag/tag.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useTag = require('../../../hooks/useTag/useTag.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const tag = () => {
+    if (jsx.useContext(useTag.tagContext)) {
+        throw Error('You cannot use a <tag> inside another one');
+    }
+    const { name, description } = jsx.useProps();
+    const children = jsx.useChildren();
+    const { docs } = useApi.useApi();
+    const tag = description ? { name, description } : { name };
+    if (!docs.tags) {
+        docs.tags = [tag];
+    }
+    else if (!docs.tags.find(({ name: tagName }) => tagName === name)) {
+        docs.tags.push(tag);
+    }
+    else {
+        throw Error(`You cannot use two tags with the same name (${name})`);
+    }
+    const handler = innet.useNewHandler();
+    handler[useTag.tagContext.key] = tag;
+    innet__default["default"](children, handler);
+};
+
+exports.tag = tag;

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

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

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

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

package/plugins/main/variable/index.js

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

package/plugins/main/variable/variable.d.ts

@@ -0,0 +1,24 @@
+import { type HandlerPlugin } from 'innet';
+export interface VariableProps {
+    /**
+     * A server url parameter
+     * */
+    key: string;
+    /**
+     * The default value to use for substitution,
+     * which SHALL be sent if an alternate value is not supplied.
+     * If the `values` is defined, the `value` MUST exist in the `values`.
+     * */
+    value?: string;
+    /**
+     * An enumeration of string values to be used if the substitution options are from a limited set.
+     * The array MUST NOT be empty.
+     * */
+    values?: [string, string, ...string[]];
+    /**
+     * An optional description for the server variable.
+     * [CommonMark syntax](https://spec.commonmark.org) MAY be used for rich text representation.
+     * */
+    description?: string;
+}
+export declare const variable: HandlerPlugin;

package/plugins/main/variable/variable.es6.js

@@ -0,0 +1,16 @@
+import { __rest } from 'tslib';
+import { useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useHost } from '../../../hooks/useHost/useHost.es6.js';
+
+const variable = () => {
+    const { server } = useHost();
+    const _a = useProps(), { key, values, value = values === null || values === void 0 ? void 0 : values[0] } = _a, rest = __rest(_a, ["key", "values", "value"]);
+    if (!server.variables) {
+        server.variables = {};
+    }
+    // @ts-expect-error: FIXME
+    server.variables[key] = Object.assign(Object.assign({}, rest), { default: value, enum: values });
+};
+
+export { variable };

package/plugins/main/variable/variable.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useHost = require('../../../hooks/useHost/useHost.js');
+
+const variable = () => {
+    const { server } = useHost.useHost();
+    const _a = jsx.useProps(), { key, values, value = values === null || values === void 0 ? void 0 : values[0] } = _a, rest = tslib.__rest(_a, ["key", "values", "value"]);
+    if (!server.variables) {
+        server.variables = {};
+    }
+    // @ts-expect-error: FIXME
+    server.variables[key] = Object.assign(Object.assign({}, rest), { default: value, enum: values });
+};
+
+exports.variable = variable;

package/plugins/request/cms/cms.d.ts

@@ -0,0 +1,5 @@
+export interface CmsProps {
+    dir?: string;
+    prefix?: string;
+}
+export declare function cms(): void;

package/plugins/request/cms/cms.es6.js

@@ -0,0 +1,24 @@
+import innet, { useHandler } from 'innet';
+import { useProps, useChildren } from '@innet/jsx';
+import path from 'node:path';
+import '../file/index.es6.js';
+import '../../../hooks/index.es6.js';
+import { usePath } from '../../../hooks/usePath/usePath.es6.js';
+import { file } from '../file/file.es6.js';
+
+function cms() {
+    const { prefix = '/', dir = '.' } = useProps() || {};
+    const children = useChildren();
+    const handler = useHandler();
+    let url = usePath();
+    if (url.startsWith(prefix)) {
+        url = url.slice(prefix.length);
+    }
+    else {
+        return innet(children, handler);
+    }
+    const filePath = path.join(dir, url);
+    innet({ type: file, props: { path: filePath }, children }, handler);
+}
+
+export { cms };

package/plugins/request/cms/cms.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+var path = require('node:path');
+require('../file/index.js');
+require('../../../hooks/index.js');
+var usePath = require('../../../hooks/usePath/usePath.js');
+var file = require('../file/file.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+function cms() {
+    const { prefix = '/', dir = '.' } = jsx.useProps() || {};
+    const children = jsx.useChildren();
+    const handler = innet.useHandler();
+    let url = usePath.usePath();
+    if (url.startsWith(prefix)) {
+        url = url.slice(prefix.length);
+    }
+    else {
+        return innet__default["default"](children, handler);
+    }
+    const filePath = path__default["default"].join(dir, url);
+    innet__default["default"]({ type: file.file, props: { path: filePath }, children }, handler);
+}
+
+exports.cms = cms;

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

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

package/plugins/request/cookie/cookie.d.ts

@@ -0,0 +1,7 @@
+import { type HandlerPlugin } from 'innet';
+import { type CookieSerializeOptions } from 'cookie';
+export interface CookieProps extends CookieSerializeOptions {
+    key: string;
+    value?: string;
+}
+export declare const cookie: HandlerPlugin;

package/plugins/request/cookie/cookie.es6.js

@@ -0,0 +1,28 @@
+import { __rest } from 'tslib';
+import { useProps } from '@innet/jsx';
+import cookie$1 from 'cookie';
+import '../../../hooks/index.es6.js';
+import { useResponse } from '../../../hooks/useResponse/useResponse.es6.js';
+import { useThrow } from '../../../hooks/useThrow/useThrow.es6.js';
+
+const cookie = () => {
+    const res = useResponse();
+    if (!res) {
+        useThrow('<{type}> MUST be in <request> or <fallback>');
+    }
+    const _a = useProps(), { key, value } = _a, opt = __rest(_a, ["key", "value"]);
+    let cookies = res.getHeader('Set-Cookie');
+    if (typeof cookies === 'string') {
+        cookies = [cookies];
+    }
+    const normValue = typeof value === 'string' ? cookie$1.serialize(key, value, opt) : `${key}=; max-age=0`;
+    if (cookies) {
+        cookies.push(normValue);
+    }
+    else {
+        cookies = normValue;
+    }
+    res.setHeader('Set-Cookie', cookies);
+};
+
+export { cookie };

package/plugins/request/cookie/cookie.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var jsx = require('@innet/jsx');
+var cookie$1 = require('cookie');
+require('../../../hooks/index.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 cookie__default = /*#__PURE__*/_interopDefaultLegacy(cookie$1);
+
+const cookie = () => {
+    const res = useResponse.useResponse();
+    if (!res) {
+        useThrow.useThrow('<{type}> MUST be in <request> or <fallback>');
+    }
+    const _a = jsx.useProps(), { key, value } = _a, opt = tslib.__rest(_a, ["key", "value"]);
+    let cookies = res.getHeader('Set-Cookie');
+    if (typeof cookies === 'string') {
+        cookies = [cookies];
+    }
+    const normValue = typeof value === 'string' ? cookie__default["default"].serialize(key, value, opt) : `${key}=; max-age=0`;
+    if (cookies) {
+        cookies.push(normValue);
+    }
+    else {
+        cookies = normValue;
+    }
+    res.setHeader('Set-Cookie', cookies);
+};
+
+exports.cookie = cookie;

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

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