@innet/server 2.0.0-beta.15 → 2.0.0-beta.17

package/hooks/index.d.ts

@@ -6,6 +6,7 @@ export * from './useBodyFile';
 export * from './useClientIp';
 export * from './useComponentName';
 export * from './useCookies';
+export * from './useData';
 export * from './useEffect';
 export * from './useEndpoint';
 export * from './useHeaders';

package/hooks/index.es6.js

@@ -6,6 +6,7 @@ import './useBodyFile/index.es6.js';
 import './useClientIp/index.es6.js';
 import './useComponentName/index.es6.js';
 import './useCookies/index.es6.js';
+import './useData/index.es6.js';
 import './useEffect/index.es6.js';
 import './useEndpoint/index.es6.js';
 import './useHeaders/index.es6.js';

package/hooks/index.js

@@ -8,6 +8,7 @@ require('./useBodyFile/index.js');
 require('./useClientIp/index.js');
 require('./useComponentName/index.js');
 require('./useCookies/index.js');
+require('./useData/index.js');
 require('./useEffect/index.js');
 require('./useEndpoint/index.js');
 require('./useHeaders/index.js');

package/hooks/useData/index.d.ts

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

package/hooks/useData/index.es6.js

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

package/hooks/useData/index.js

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

package/hooks/useData/useData.d.ts

@@ -0,0 +1,2 @@
+import { type ApiEndpoints, type TEndpoint } from '../../types';
+export declare function useData<F extends Exclude<keyof TEndpoint, 'response'>, D extends keyof ApiEndpoints>(from: F, path?: D): ApiEndpoints[D][F];

package/hooks/useData/useData.es6.js

@@ -0,0 +1,23 @@
+import '../useAction/index.es6.js';
+import '../useEndpoint/index.es6.js';
+import '../useThrow/index.es6.js';
+import { useEndpoint } from '../useEndpoint/useEndpoint.es6.js';
+import { useThrow } from '../useThrow/useThrow.es6.js';
+import { useAction } from '../useAction/useAction.es6.js';
+
+function useData(from, path) {
+    if (path) {
+        const endpoint = useEndpoint();
+        const endpointKey = `${endpoint.props.method.toUpperCase()}:${endpoint.props.path}`;
+        if (endpointKey !== path) {
+            useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
+        }
+    }
+    const action = useAction();
+    if (!action) {
+        useThrow('<{type}> MUST be in <return> or <preset>');
+    }
+    return action[from];
+}
+
+export { useData };

package/hooks/useData/useData.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../useAction/index.js');
+require('../useEndpoint/index.js');
+require('../useThrow/index.js');
+var useEndpoint = require('../useEndpoint/useEndpoint.js');
+var useThrow = require('../useThrow/useThrow.js');
+var useAction = require('../useAction/useAction.js');
+
+function useData(from, path) {
+    if (path) {
+        const endpoint = useEndpoint.useEndpoint();
+        const endpointKey = `${endpoint.props.method.toUpperCase()}:${endpoint.props.path}`;
+        if (endpointKey !== path) {
+            useThrow.useThrow(`<{type}> MUST be in <endpoint> of ${path}`);
+        }
+    }
+    const action = useAction.useAction();
+    if (!action) {
+        useThrow.useThrow('<{type}> MUST be in <return> or <preset>');
+    }
+    return action[from];
+}
+
+exports.useData = useData;

package/index.es6.js

@@ -12,6 +12,7 @@ export { bodyFileContext, useBodyFile } from './hooks/useBodyFile/useBodyFile.es
 export { useClientIp } from './hooks/useClientIp/useClientIp.es6.js';
 export { useComponentName } from './hooks/useComponentName/useComponentName.es6.js';
 export { useCookies } from './hooks/useCookies/useCookies.es6.js';
+export { useData } from './hooks/useData/useData.es6.js';
 export { useEffect } from './hooks/useEffect/useEffect.es6.js';
 export { endpointContext, useEndpoint } from './hooks/useEndpoint/useEndpoint.es6.js';
 export { useHeaders } from './hooks/useHeaders/useHeaders.es6.js';

package/index.js

@@ -16,6 +16,7 @@ var useBodyFile = require('./hooks/useBodyFile/useBodyFile.js');
 var useClientIp = require('./hooks/useClientIp/useClientIp.js');
 var useComponentName = require('./hooks/useComponentName/useComponentName.js');
 var useCookies = require('./hooks/useCookies/useCookies.js');
+var useData = require('./hooks/useData/useData.js');
 var useEffect = require('./hooks/useEffect/useEffect.js');
 var useEndpoint = require('./hooks/useEndpoint/useEndpoint.js');
 var useHeaders = require('./hooks/useHeaders/useHeaders.js');
@@ -144,6 +145,7 @@ exports.useBodyFile = useBodyFile.useBodyFile;
 exports.useClientIp = useClientIp.useClientIp;
 exports.useComponentName = useComponentName.useComponentName;
 exports.useCookies = useCookies.useCookies;
+exports.useData = useData.useData;
 exports.useEffect = useEffect.useEffect;
 exports.endpointContext = useEndpoint.endpointContext;
 exports.useEndpoint = useEndpoint.useEndpoint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innet/server",
-  "version": "2.0.0-beta.15",
+  "version": "2.0.0-beta.17",
   "description": "Create server-side application with innet",
   "main": "index.js",
   "module": "index.es6.js",

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

@@ -1,6 +1,7 @@
 import { type HandlerPlugin } from 'innet';
 import { type ErrorStatuses, type RedirectStatuses, type SuccessStatuses } from '../../request';
 export type StatusKey = ErrorStatuses | RedirectStatuses | SuccessStatuses;
+export type ResponseStatus = 'default' | `${1 | 2 | 3 | 4 | 5}XX` | StatusKey | number;
 export interface ResponseProps {
     children?: any;
     /**
@@ -14,7 +15,7 @@ export interface ResponseProps {
      * For example, 2XX represents all response codes between [200-299].
      * Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX.
      * */
-    status?: 'default' | `${1 | 2 | 3 | 4 | 5}XX` | StatusKey | number;
+    status?: ResponseStatus;
     type?: string;
 }
 export declare const statuses: Record<StatusKey, number>;

package/types.d.ts

@@ -1,6 +1,7 @@
 import type { OpenAPIV3_1 as API } from 'openapi-types';
 import type { ApiErrorValue } from './constants';
 import { type ServerPlugin } from './hooks';
+import { type ResponseStatus } from './plugins';
 import { type Rule, type RulesErrors } from './utils/rules';
 export type TagObject = API.TagObject;
 export type Document = API.Document;
@@ -74,3 +75,14 @@ export interface ValuesSchemaProps<T> extends BaseSchemaProps<T> {
     value?: T;
     values?: SchemaValues<T>;
 }
+export type TResponse = Record<ResponseStatus, unknown>;
+export interface TEndpoint {
+    body?: unknown;
+    cookies?: Record<string, string>;
+    headers?: Record<string, string>;
+    params?: Record<string, unknown>;
+    response?: Record<string, TResponse>;
+    search?: Record<string, unknown>;
+}
+export type ApiEndpoints = Record<string, TEndpoint>;
+export type ApiSchemas = Record<string, unknown>;

package/utils/generateTypes/generateTypes.es6.js

@@ -15,67 +15,85 @@ function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
     if ('$ref' in schema) {
         return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
     }
-    if (schema.type === 'integer') {
-        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
-    }
-    if (schema.type === 'string') {
-        if (schema.format === 'date-time') {
-            return `Date${lastChar}`;
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    let scope = '';
+    for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        const operator = i ? ' | ' : '';
+        if (schema.oneOf) {
+            let result = '';
+            for (const item of schema.oneOf) {
+                if (result) {
+                    result += ' | ';
+                }
+                result += generateSchemaTypes(item, spaces + 2, '');
+            }
+            scope += `${operator}${result}`;
+            continue;
         }
-        if (schema.format === 'binary') {
-            return `Bin${lastChar}`;
+        if (!type) {
+            scope += `${operator}any`;
+            continue;
         }
-        return `string${lastChar}`;
-    }
-    if (['boolean', 'null', 'number'].includes(schema.type)) {
-        return `${schema.type}${lastChar}`;
-    }
-    if (schema.oneOf) {
-        let result = '';
-        for (const item of schema.oneOf) {
-            if (result) {
-                result += ' | ';
+        if (type === 'integer') {
+            scope += `${operator}${schema.format === 'int64' ? 'bigint' : 'number'}`;
+            continue;
+        }
+        if (type === 'string') {
+            if (schema.format === 'date-time') {
+                scope += `${operator}Date`;
+                continue;
             }
-            result += generateSchemaTypes(item, spaces + 2, '');
+            if (schema.format === 'binary') {
+                scope += `${operator}Bin`;
+                continue;
+            }
+            scope += `${operator}string`;
+            continue;
         }
-        return result + lastChar;
-    }
-    if (schema.type === 'array') {
-        if (!schema.items)
-            return `any[]${lastChar}`;
-        return `Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>${lastChar}`;
-    }
-    if (!schema.type) {
-        return `any${lastChar}`;
-    }
-    if (schema.type !== 'object') {
-        console.error('unknown type', schema);
-        return `any${lastChar}`;
-    }
-    let result = '{\n';
-    const required = schema.required || [];
-    const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
-    const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
-        Object.keys(schema.additionalProperties).length);
-    if (hasProps) {
-        for (const key in schema.properties) {
-            const prop = schema.properties[key];
-            const splitter = required.includes(key) || hasDefault(prop)
-                ? ':'
-                : '?:';
-            if ('deprecated' in prop && prop.deprecated) {
-                result += `${space}/** @deprecated */\n`;
+        if (['boolean', 'null', 'number'].includes(type)) {
+            scope += `${operator}${type}`;
+            continue;
+        }
+        if (type === 'array') {
+            if (schema.type !== 'array' || !schema.items) {
+                scope += `${operator}any[]`;
+                continue;
             }
-            result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+            scope += `${operator}Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>`;
+            continue;
         }
+        if (type !== 'object') {
+            console.error('Error: Unknown Type', schema);
+            scope += `${operator}any`;
+            continue;
+        }
+        let result = '{\n';
+        const required = schema.required || [];
+        const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
+        const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
+            Object.keys(schema.additionalProperties).length);
+        if (hasProps) {
+            for (const key in schema.properties) {
+                const prop = schema.properties[key];
+                const splitter = required.includes(key) || hasDefault(prop)
+                    ? ':'
+                    : '?:';
+                if ('deprecated' in prop && prop.deprecated) {
+                    result += `${space}/** @deprecated */\n`;
+                }
+                result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+            }
+        }
+        if (hasRestProps) {
+            const value = hasProps
+                ? 'any\n'
+                : generateSchemaTypes(schema.additionalProperties, spaces + 2);
+            result += `${space}[key: string]: ${value}`;
+        }
+        scope += `${operator}${result}${space.slice(0, -2)}}`;
     }
-    if (hasRestProps) {
-        const value = hasProps
-            ? 'any\n'
-            : generateSchemaTypes(schema.additionalProperties, spaces + 2);
-        result += `${space}[key: string]: ${value}`;
-    }
-    return `${result}${space.slice(0, -2)}}${lastChar}`;
+    return `${scope}${lastChar}`;
 }
 function generateTypes(docs, namespace = 'Api') {
     var _a;
@@ -94,9 +112,9 @@ function generateTypes(docs, namespace = 'Api') {
     const schemas = (_a = docs.components) === null || _a === void 0 ? void 0 : _a.schemas;
     const paths = docs.paths;
     if (schemas) {
-        result += '  namespace Schemas {\n';
+        result += '  export interface Schemas {\n';
         for (const name in schemas) {
-            result += `    export type ${name} = ${generateSchemaTypes(schemas[name], 6)}`;
+            result += `    ${name}: ${generateSchemaTypes(schemas[name], 6)}`;
         }
         result += '  }\n';
     }
@@ -125,23 +143,23 @@ function generateTypes(docs, namespace = 'Api') {
                     params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
                 }
                 if (params.path) {
-                    result += `      Params: {\n${params.path}      }\n`;
+                    result += `      params: {\n${params.path}      }\n`;
                 }
                 if (params.query) {
-                    result += `      Search: {\n${params.query}      }\n`;
+                    result += `      search: {\n${params.query}      }\n`;
                 }
                 if (params.header) {
-                    result += `      Headers: {\n${params.header}      }\n`;
+                    result += `      headers: {\n${params.header}      }\n`;
                 }
                 if (params.cookie) {
-                    result += `      Cookies: {\n${params.cookie}      }\n`;
+                    result += `      cookies: {\n${params.cookie}      }\n`;
                 }
             }
             if (requestBody) {
-                result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
+                result += `      body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
             }
             if (responses) {
-                result += '      Response: {\n';
+                result += '      response: {\n';
                 for (const key in responses) {
                     let multiple = false;
                     const response = responses[key];
@@ -165,7 +183,14 @@ function generateTypes(docs, namespace = 'Api') {
             result += '    }\n';
         }
     }
-    return result + '  }\n}';
+    const body = result + '  }\n}';
+    return `${body}
+
+declare module '@innet/server' {
+  type ApiEndpoints = ${namespace}.Endpoints
+  type ApiSchemas = ${namespace}.Schemas
+}
+`;
 }
 
 export { generateSchemaTypes, generateTypes };

package/utils/generateTypes/generateTypes.js

@@ -19,67 +19,85 @@ function generateSchemaTypes(schema, spaces = 2, lastChar = '\n') {
     if ('$ref' in schema) {
         return `Schemas.${schema.$ref.slice(21)}${lastChar}`;
     }
-    if (schema.type === 'integer') {
-        return `${schema.format === 'int64' ? 'bigint' : 'number'}${lastChar}`;
-    }
-    if (schema.type === 'string') {
-        if (schema.format === 'date-time') {
-            return `Date${lastChar}`;
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    let scope = '';
+    for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        const operator = i ? ' | ' : '';
+        if (schema.oneOf) {
+            let result = '';
+            for (const item of schema.oneOf) {
+                if (result) {
+                    result += ' | ';
+                }
+                result += generateSchemaTypes(item, spaces + 2, '');
+            }
+            scope += `${operator}${result}`;
+            continue;
         }
-        if (schema.format === 'binary') {
-            return `Bin${lastChar}`;
+        if (!type) {
+            scope += `${operator}any`;
+            continue;
         }
-        return `string${lastChar}`;
-    }
-    if (['boolean', 'null', 'number'].includes(schema.type)) {
-        return `${schema.type}${lastChar}`;
-    }
-    if (schema.oneOf) {
-        let result = '';
-        for (const item of schema.oneOf) {
-            if (result) {
-                result += ' | ';
+        if (type === 'integer') {
+            scope += `${operator}${schema.format === 'int64' ? 'bigint' : 'number'}`;
+            continue;
+        }
+        if (type === 'string') {
+            if (schema.format === 'date-time') {
+                scope += `${operator}Date`;
+                continue;
             }
-            result += generateSchemaTypes(item, spaces + 2, '');
+            if (schema.format === 'binary') {
+                scope += `${operator}Bin`;
+                continue;
+            }
+            scope += `${operator}string`;
+            continue;
         }
-        return result + lastChar;
-    }
-    if (schema.type === 'array') {
-        if (!schema.items)
-            return `any[]${lastChar}`;
-        return `Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>${lastChar}`;
-    }
-    if (!schema.type) {
-        return `any${lastChar}`;
-    }
-    if (schema.type !== 'object') {
-        console.error('unknown type', schema);
-        return `any${lastChar}`;
-    }
-    let result = '{\n';
-    const required = schema.required || [];
-    const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
-    const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
-        Object.keys(schema.additionalProperties).length);
-    if (hasProps) {
-        for (const key in schema.properties) {
-            const prop = schema.properties[key];
-            const splitter = required.includes(key) || hasDefault(prop)
-                ? ':'
-                : '?:';
-            if ('deprecated' in prop && prop.deprecated) {
-                result += `${space}/** @deprecated */\n`;
+        if (['boolean', 'null', 'number'].includes(type)) {
+            scope += `${operator}${type}`;
+            continue;
+        }
+        if (type === 'array') {
+            if (schema.type !== 'array' || !schema.items) {
+                scope += `${operator}any[]`;
+                continue;
             }
-            result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+            scope += `${operator}Array<${generateSchemaTypes(schema.items, spaces + 2, '')}>`;
+            continue;
         }
+        if (type !== 'object') {
+            console.error('Error: Unknown Type', schema);
+            scope += `${operator}any`;
+            continue;
+        }
+        let result = '{\n';
+        const required = schema.required || [];
+        const hasProps = Boolean(schema.properties && Object.keys(schema.properties).length);
+        const hasRestProps = Boolean(typeof schema.additionalProperties === 'object' &&
+            Object.keys(schema.additionalProperties).length);
+        if (hasProps) {
+            for (const key in schema.properties) {
+                const prop = schema.properties[key];
+                const splitter = required.includes(key) || hasDefault(prop)
+                    ? ':'
+                    : '?:';
+                if ('deprecated' in prop && prop.deprecated) {
+                    result += `${space}/** @deprecated */\n`;
+                }
+                result += `${space}${key}${splitter} ${generateSchemaTypes(prop, spaces + 2)}`;
+            }
+        }
+        if (hasRestProps) {
+            const value = hasProps
+                ? 'any\n'
+                : generateSchemaTypes(schema.additionalProperties, spaces + 2);
+            result += `${space}[key: string]: ${value}`;
+        }
+        scope += `${operator}${result}${space.slice(0, -2)}}`;
     }
-    if (hasRestProps) {
-        const value = hasProps
-            ? 'any\n'
-            : generateSchemaTypes(schema.additionalProperties, spaces + 2);
-        result += `${space}[key: string]: ${value}`;
-    }
-    return `${result}${space.slice(0, -2)}}${lastChar}`;
+    return `${scope}${lastChar}`;
 }
 function generateTypes(docs, namespace = 'Api') {
     var _a;
@@ -98,9 +116,9 @@ function generateTypes(docs, namespace = 'Api') {
     const schemas = (_a = docs.components) === null || _a === void 0 ? void 0 : _a.schemas;
     const paths = docs.paths;
     if (schemas) {
-        result += '  namespace Schemas {\n';
+        result += '  export interface Schemas {\n';
         for (const name in schemas) {
-            result += `    export type ${name} = ${generateSchemaTypes(schemas[name], 6)}`;
+            result += `    ${name}: ${generateSchemaTypes(schemas[name], 6)}`;
         }
         result += '  }\n';
     }
@@ -129,23 +147,23 @@ function generateTypes(docs, namespace = 'Api') {
                     params[param.in] += `        ${param.name}${splitter} ${generateSchemaTypes(param.schema)}`;
                 }
                 if (params.path) {
-                    result += `      Params: {\n${params.path}      }\n`;
+                    result += `      params: {\n${params.path}      }\n`;
                 }
                 if (params.query) {
-                    result += `      Search: {\n${params.query}      }\n`;
+                    result += `      search: {\n${params.query}      }\n`;
                 }
                 if (params.header) {
-                    result += `      Headers: {\n${params.header}      }\n`;
+                    result += `      headers: {\n${params.header}      }\n`;
                 }
                 if (params.cookie) {
-                    result += `      Cookies: {\n${params.cookie}      }\n`;
+                    result += `      cookies: {\n${params.cookie}      }\n`;
                 }
             }
             if (requestBody) {
-                result += `      Body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
+                result += `      body: ${generateSchemaTypes(requestBody.content['multipart/form-data'].schema, 8)}`;
             }
             if (responses) {
-                result += '      Response: {\n';
+                result += '      response: {\n';
                 for (const key in responses) {
                     let multiple = false;
                     const response = responses[key];
@@ -169,7 +187,14 @@ function generateTypes(docs, namespace = 'Api') {
             result += '    }\n';
         }
     }
-    return result + '  }\n}';
+    const body = result + '  }\n}';
+    return `${body}
+
+declare module '@innet/server' {
+  type ApiEndpoints = ${namespace}.Endpoints
+  type ApiSchemas = ${namespace}.Schemas
+}
+`;
 }
 
 exports.generateSchemaTypes = generateSchemaTypes;