kb-server 0.0.1-beta.8 → 0.0.2-beta.1

package/README.md

@@ -1,14 +1,44 @@
 # KB Server
 
-快速创建一个 Node 服务
+快速创建一个 `Node` 服务 - 基于 `Express`
 
-快速创建 API、标准错误码、Server、支持统一鉴权函数（API 级别）
+快速创建 `API`、标准错误码、`Server`、支持统一鉴权函数（API 级别）、自定义中间件、日志、支持 `SSE`
 
-```javascript
+```typescript
 import { createServer } from "kb-server";
 import * as apis from "./apis";
 
+// 写法一
+const server = createServer({ apis });
+server.listen(3000);
+
+// 写法二
 (async () => {
+  // 其他的异步操作，例如：初始化数据库
   return createServer({ apis });
 })().then((app) => app.listen(3000));
 ```
+
+## SSE 支持
+
+```typescript
+import { createServer } from "kb-server";
+import * as apis from "./apis";
+import * as sse from "./sse";
+
+
+(async () => {
+  // 其他的异步操作，例如：初始化数据库
+  return createServer({
+    apis,
+    sse: {
+      handlers: sse, // ...SSE处理函数
+    },
+    authFn: (action, req) => {
+      // ...统一鉴权函数
+    },
+    middlewares: [], // ...中间键列表
+    log: true, // ...框架日志
+  });
+})().then((app) => app.listen(3000));
+```

package/dist/common/api-middleware.js

@@ -27,7 +27,7 @@ const packAPI = (apis, options) => {
             // API 解析
             const { Action, ...params } = req.body || {};
             if (log) {
-                logger_1.logger.log("info", `请求入参：${JSON.stringify(req.body)} - RequestId: ${requestId}`);
+                logger_1.logger.info(`请求入参：${JSON.stringify(req.body)} - RequestId: ${requestId}`);
             }
             // 接口未定义
             if (!Action) {
@@ -63,12 +63,12 @@ const packAPI = (apis, options) => {
             };
             // 完成响应
             took = Date.now() - start;
-            logger_1.logger.log("info", response);
-            logger_1.logger.log("info", `耗时：${took} ms - RequestId: ${requestId}`);
+            logger_1.logger.info(`响应：${JSON.stringify(response)}`);
+            logger_1.logger.info(`耗时：${took} ms - RequestId: ${requestId}`);
             return res.send(response);
         }
         catch (rawError) {
-            logger_1.logger.log("error", rawError);
+            logger_1.logger.error(rawError);
             // 未知错误
             let error = new create_errors_1.CommonErrors.InternalError.UnknownError();
             // 可控错误
@@ -90,8 +90,8 @@ const packAPI = (apis, options) => {
             };
             // 完成响应
             took = Date.now() - start;
-            logger_1.logger.log("info", response);
-            logger_1.logger.log("info", `耗时：${took} ms - RequestId: ${requestId}`);
+            logger_1.logger.info(`响应：${JSON.stringify(response)}`);
+            logger_1.logger.info(`耗时：${took} ms - RequestId: ${requestId}`);
             return res.send(response);
         }
     };

package/dist/common/call-service.d.ts

@@ -0,0 +1 @@
+export declare const callService: <P = Record<string, any>, R = any>(endpoint: string, body: P) => Promise<R>;

package/dist/common/call-service.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callService = void 0;
+const create_errors_1 = require("./create-errors");
+const callService = async (endpoint, body) => {
+    const response = await fetch(endpoint, {
+        headers: {
+            "Content-Type": "application/json",
+        },
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    const result = await response.json();
+    if (result?.Response?.Error) {
+        const errMsg = result.Response.Error?.Message;
+        if (errMsg) {
+            throw new create_errors_1.CommonErrors.InternalError.ServiceError(errMsg);
+        }
+        throw new create_errors_1.CommonErrors.InternalError.ServiceError();
+    }
+    return result?.Response?.Data;
+};
+exports.callService = callService;

package/dist/common/create-api.d.ts

@@ -1,19 +1,24 @@
+import { ValidationError } from "class-validator";
 import { Class } from "utility-types";
-export interface ServerContext {
+export interface ServerContext<A = any> {
     /** 被调用方的 RequestId */
     RequestId: string;
     /** 权限信息 */
-    AuthInfo?: Record<string, any>;
+    AuthInfo?: A;
 }
 export type API<P, R> = (param: P) => Promise<R>;
-export type APIExecution<P, R> = (
+export type APIExecution<P, R, A> = (
 /** 请求入参 */
 params: P, 
 /** 请求上下文 */
-ctx: ServerContext) => Promise<R>;
-export type AnyAPIExecution = APIExecution<any, any>;
+ctx: ServerContext<A>) => Promise<R>;
+export type AnyAPIExecution = APIExecution<any, any, any>;
 export type APIs = Record<string, AnyAPIExecution>;
-export declare function createAPI<P, R>(ParamsClass: Class<P>, execution: APIExecution<P, R>): API<P, R>;
+export declare function createAPI<P, R, A>(ParamsClass: Class<P>, execution: APIExecution<P, R, A>): API<P, R>;
 type StubParam<T> = T extends (params: infer P) => any ? P : never;
-export declare function implementAPI<A extends (params: any) => any>(_actionStub: A, ParamsClass: Class<StubParam<A>>, execution: APIExecution<StubParam<A>, ReturnType<A>>): API<StubParam<A>, ReturnType<A>>;
+export declare function implementAPI<F extends (params: any) => any, A = Record<string, any>>(_actionStub: F, ParamsClass: Class<StubParam<F>>, execution: APIExecution<StubParam<F>, ReturnType<F>, A>): API<StubParam<F>, ReturnType<F>>;
+/**
+ * 解析错误信息
+ */
+export declare function getMessage(message: ValidationError, propertyPath?: string): string[];
 export {};

package/dist/common/create-api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.implementAPI = exports.createAPI = void 0;
+exports.getMessage = exports.implementAPI = exports.createAPI = void 0;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const create_errors_1 = require("./create-errors");
@@ -15,10 +15,8 @@ function createAPI(ParamsClass, execution) {
             : (0, class_transformer_1.plainToClass)(ParamsClass, params);
         const errors = await (0, class_validator_1.validate)(paramsToCheck || {});
         if (errors?.length) {
-            const messages = errors.map((x, index) => {
-                return `\n${index}.<${x.property}>:${Object.values(x.constraints || { unknown: "reason unknown" }).join(", ")}`;
-            });
-            throw new create_errors_1.CommonErrors.InvalidParameter.ValidationError(messages.join(" "));
+            const errorMessages = errors.flatMap((error) => getMessage(error));
+            throw new create_errors_1.CommonErrors.InvalidParameter.ValidationError(errorMessages.join("\n"));
         }
         // 执行函数
         return await execution(params, ctx);
@@ -30,3 +28,26 @@ function implementAPI(_actionStub, ParamsClass, execution) {
     return createAPI(ParamsClass, execution);
 }
 exports.implementAPI = implementAPI;
+/**
+ * 解析错误信息
+ */
+function getMessage(message, propertyPath = "") {
+    const messages = [];
+    // 构建当前属性的完整路径
+    const currentPropertyPath = propertyPath
+        ? `${propertyPath}.${message.property}`
+        : message.property;
+    if (message.constraints) {
+        // 将所有约束错误合并为一个字符串
+        const constraintErrors = Object.values(message.constraints).join(", ");
+        messages.push(`${currentPropertyPath}: ${constraintErrors}`);
+    }
+    if (message.children && message.children.length > 0) {
+        // 递归处理子错误，并传递更新后的属性路径
+        for (const [_index, child] of message.children.entries()) {
+            messages.push(...getMessage(child, currentPropertyPath));
+        }
+    }
+    return messages;
+}
+exports.getMessage = getMessage;

package/dist/common/create-errors.d.ts

@@ -21,6 +21,7 @@ declare const CommonErrorsMap: {
         readonly EmptyParameter: "请求参数不能为空";
         readonly EmptyAPIRequest: "未指定API的请求";
         readonly ValidationError: "参数校验失败";
+        readonly RouteError: "路由错误";
     };
     readonly ResourceNotFound: {
         readonly APINotFound: "不存在的API";
@@ -77,6 +78,7 @@ declare function createErrorsClasses<T extends MessageMap = MessageMap>(messageM
         readonly EmptyParameter: "请求参数不能为空";
         readonly EmptyAPIRequest: "未指定API的请求";
         readonly ValidationError: "参数校验失败";
+        readonly RouteError: "路由错误";
     };
     readonly ResourceNotFound: {
         readonly APINotFound: "不存在的API";
@@ -102,6 +104,7 @@ export declare const CommonErrors: ErrorClasses<MergeMessageMap<{
         readonly EmptyParameter: "请求参数不能为空";
         readonly EmptyAPIRequest: "未指定API的请求";
         readonly ValidationError: "参数校验失败";
+        readonly RouteError: "路由错误";
     };
     readonly ResourceNotFound: {
         readonly APINotFound: "不存在的API";

package/dist/common/create-errors.js

@@ -23,6 +23,7 @@ const CommonErrorsMap = {
         EmptyParameter: "请求参数不能为空",
         EmptyAPIRequest: "未指定API的请求",
         ValidationError: "参数校验失败",
+        RouteError: "路由错误",
     },
     ResourceNotFound: {
         APINotFound: "不存在的API",

package/dist/common/create-server.d.ts

@@ -1,10 +1,35 @@
+import express from "express";
 import { AuthFunction } from "./api-middleware";
 import { APIs } from "./create-api";
+import { SseHandlers } from "./create-sse";
 export interface ICreateServerParams {
     /**
      * API列表
      */
     apis: APIs;
+    /**
+     * SSE配置
+     */
+    sse?: {
+        /**
+         * SSE API列表
+         */
+        handlers: SseHandlers;
+        /**
+         * SSE 监听的路由，例如：`/sse/generate`
+         *
+         * 注意：路由要以 `/` 开头
+         *
+         * 默认为：`/sse`
+         */
+        route?: string;
+        /**
+         * 超时时间（单位：毫秒）
+         *
+         * @description 从第一次推送消息时开始计时，每次推送消息会重置超时时间
+         */
+        timeout?: number;
+    };
     /**
      * 鉴权函数
      *
@@ -15,6 +40,31 @@ export interface ICreateServerParams {
      * 默认请求日志，true开启，false关闭
      */
     log?: boolean;
+    /**
+     * 自定义中间件列表
+     *
+     * @example
+     *
+     * ```
+     * import cors from "cors"; // 引入cors中间件
+     *
+     * ...其他代码...
+     *
+     * const server = createServer(
+     *  {
+     *    apis: myAPIs,
+     *    authFn: myAuthFunction,
+     *    log: true,
+     *    middlewares: [cors()], // 传入cors中间件
+     *  },
+     *  {
+     *    limit: "5mb",
+     *  }
+     *);
+     * ```
+     *
+     */
+    middlewares?: express.RequestHandler[];
 }
 export interface ICreateServerOptions {
     limit?: string | number | undefined;

package/dist/common/create-server.js

@@ -26,16 +26,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = void 0;
 const express_1 = __importStar(require("express"));
 const api_middleware_1 = require("./api-middleware");
+const sse_middleware_1 = require("./sse-middleware");
 /**
  * 创建 Server
  */
 function createServer(params, options) {
-    const { apis, authFn, log } = params || {};
+    const { apis, sse, authFn, log, middlewares = [] } = params || {};
     const { limit = "10mb" } = options || {};
+    const { handlers, ...resetSSE } = sse || {};
     const app = (0, express_1.default)();
     // POST 参数获取
     app.use((0, express_1.urlencoded)({ extended: true, limit }));
     app.use((0, express_1.json)({ limit }));
+    // 使用自定义中间件
+    middlewares.forEach((middleware) => app.use(middleware));
+    // 注入SSE
+    handlers && app.use((0, sse_middleware_1.packSSE)(handlers, { log, ...resetSSE }));
     // 注入API
     app.use((0, api_middleware_1.packAPI)(apis, { authFn, log }));
     return app;

package/dist/common/create-sse.d.ts

@@ -0,0 +1,25 @@
+import { Class } from "utility-types";
+import { ServerContext } from "./create-api";
+export type PushHandler = (data: Record<string, any>) => void;
+export type CloseHandler = () => void;
+export type SSEHandlers = {
+    /** 数据推送 */
+    push: PushHandler;
+    /** 关闭函数（调用结束要显式关闭） */
+    close: CloseHandler;
+    abortController: AbortController;
+};
+export type API<P, R> = (param: P) => Promise<R>;
+export type SseExecution<P, R, A> = (
+/** 请求入参 */
+params: P, 
+/** SSE相关操作函数 */
+sse: SSEHandlers, 
+/** 请求上下文 */
+ctx: ServerContext<A>) => Promise<R>;
+export type AnySseExecution = SseExecution<any, any, any>;
+export type SseHandlers = Record<string, AnySseExecution>;
+export declare function createSseAPI<P, R, A>(ParamsClass: Class<P>, execution: SseExecution<P, R, A>): API<P, R>;
+type StubParam<T> = T extends (params: infer P) => any ? P : never;
+export declare function implementSseAPI<F extends (params: any) => any, A = Record<string, any>>(_actionStub: F, ParamsClass: Class<StubParam<F>>, execution: SseExecution<StubParam<F>, ReturnType<F>, A>): API<StubParam<F>, ReturnType<F>>;
+export {};

package/dist/common/create-sse.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementSseAPI = exports.createSseAPI = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const create_errors_1 = require("./create-errors");
+const create_api_1 = require("./create-api");
+function createSseAPI(ParamsClass, execution) {
+    const runtime = async (params, sse, ctx) => {
+        if (!params) {
+            throw new create_errors_1.CommonErrors.InvalidParameter.EmptyParameter();
+        }
+        // 校验参数
+        const paramsToCheck = params instanceof ParamsClass
+            ? params
+            : (0, class_transformer_1.plainToClass)(ParamsClass, params);
+        const errors = await (0, class_validator_1.validate)(paramsToCheck || {});
+        if (errors?.length) {
+            const errorMessages = errors.flatMap((error) => (0, create_api_1.getMessage)(error));
+            throw new create_errors_1.CommonErrors.InvalidParameter.ValidationError(errorMessages.join("\n"));
+        }
+        // 执行函数
+        return await execution(params, sse, ctx);
+    };
+    return runtime;
+}
+exports.createSseAPI = createSseAPI;
+function implementSseAPI(_actionStub, ParamsClass, execution) {
+    return createSseAPI(ParamsClass, execution);
+}
+exports.implementSseAPI = implementSseAPI;

package/dist/common/sse-middleware.d.ts

@@ -0,0 +1,12 @@
+import express from "express";
+import { AuthFunction } from "./api-middleware";
+import { SseHandlers } from "./create-sse";
+interface IPackSSEOptions {
+    authFn?: AuthFunction;
+    route?: string;
+    log?: boolean;
+    timeout?: number;
+}
+export declare const packSSE: (sseHandlers: SseHandlers, options?: IPackSSEOptions) => express.RequestHandler;
+export declare const createSSEMsg: (event: string, message: string) => string;
+export {};

package/dist/common/sse-middleware.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSEMsg = exports.packSSE = void 0;
+const uuid_1 = require("uuid");
+const logger_1 = require("../helper/logger");
+const create_errors_1 = require("./create-errors");
+const short_id_1 = require("../helper/short-id");
+const packSSE = (sseHandlers, options) => {
+    const { authFn, log = true, route = "/sse", timeout = 1000 * 30, } = options || {};
+    return async (req, res, next) => {
+        // 生成SSE API映射
+        const sseMap = new Map(Object.entries(sseHandlers).map(([action, execution]) => [
+            action,
+            execution,
+        ]));
+        // 检查SSE路由
+        const isValidRoute = route.startsWith("/");
+        if (!isValidRoute) {
+            throw new create_errors_1.CommonErrors.InvalidParameter.RouteError();
+        }
+        const { path } = req;
+        // 非SSE的请求直接放过
+        if (path !== route) {
+            next();
+            return;
+        }
+        // 请求开始时间
+        const start = Date.now();
+        let took = 0;
+        // 生成请求ID
+        const requestId = (0, uuid_1.v4)();
+        // 上下文
+        const ctx = {
+            RequestId: requestId,
+        };
+        try {
+            // API 解析
+            const { Action, ...params } = req.body || {};
+            if (log) {
+                logger_1.logger.info(`请求入参：${JSON.stringify(req.body)} - RequestId: ${requestId}`);
+            }
+            // 接口未定义
+            if (!Action) {
+                throw new create_errors_1.CommonErrors.InvalidParameter.EmptyAPIRequest();
+            }
+            // 处理鉴权函数
+            if (authFn !== null && authFn !== undefined) {
+                if (typeof authFn !== "function") {
+                    throw new create_errors_1.CommonErrors.ResourceNotFound.AuthFunctionNotFound();
+                }
+                const authResult = await authFn(Action, req);
+                if (!authResult) {
+                    throw new create_errors_1.CommonErrors.FailOperation.NoPermission();
+                }
+                if (typeof authResult !== "boolean") {
+                    // 把权限信息写入上下文
+                    ctx.AuthInfo = authResult || {};
+                }
+            }
+            // API 处理
+            const execution = sseMap.get(Action);
+            if (typeof execution !== "function") {
+                throw new create_errors_1.CommonErrors.ResourceNotFound.APINotFound();
+            }
+            const abortController = new AbortController();
+            let timeoutId;
+            // 连接断开
+            let isConnected = true;
+            res.on("close", () => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                isConnected = false;
+                abortController.abort();
+                // 完成响应
+                took = Date.now() - start;
+                logger_1.logger.info(`耗时：${took} ms - ${requestId}`);
+                return res.end();
+            });
+            // 写头
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            // 初始化超时定时器
+            const resetTimeout = () => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                timeoutId = setTimeout(() => {
+                    logger_1.logger.info(`超时自动关闭：${requestId}`);
+                    close();
+                }, timeout);
+            };
+            // 推送消息
+            const push = (data) => {
+                if (!isConnected) {
+                    logger_1.logger.warning(`连接已关闭： ${requestId}`);
+                    return;
+                }
+                resetTimeout();
+                const msg = createResponseMsg(data);
+                const response = (0, exports.createSSEMsg)("message", msg);
+                try {
+                    res.write(response);
+                    logger_1.logger.info(`推送数据： ${response}`);
+                }
+                catch (error) {
+                    if (error.code === "EPIPE" || error.code === "ECONNRESET") {
+                        logger_1.logger.warning(`连接已关闭： ${requestId}`);
+                        isConnected = false;
+                    }
+                }
+            };
+            // 主动关闭
+            const close = () => {
+                if (!isConnected)
+                    return;
+                logger_1.logger.info(`主动关闭连接： ${requestId}`);
+                const response = (0, exports.createSSEMsg)("done", "[DONE]");
+                res.write(response, () => res.end());
+            };
+            await execution(params, { push, close, abortController }, ctx);
+        }
+        catch (rawError) {
+            logger_1.logger.error(rawError);
+            if (!res.headersSent) {
+                // 写头
+                res.writeHead(200, {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                });
+            }
+            // 未知错误
+            let error = new create_errors_1.CommonErrors.InternalError.UnknownError();
+            // 可控错误
+            if (rawError instanceof create_errors_1.BaseError) {
+                error = rawError;
+            }
+            // DB错误
+            if (rawError?.sql) {
+                error = new create_errors_1.CommonErrors.InternalError.DatabaseError();
+            }
+            const errResponse = {
+                Response: {
+                    Error: { Code: error.code, Message: error.message },
+                    RequestId: requestId,
+                },
+            };
+            const response = (0, exports.createSSEMsg)("error", JSON.stringify(errResponse));
+            logger_1.logger.info(`发送消息：\n${response}`);
+            res.write(response, () => res.end());
+        }
+    };
+};
+exports.packSSE = packSSE;
+const createSSEMsg = (event, message) => {
+    const id = (0, short_id_1.shortId)();
+    const idStr = `id: ${id}\n`;
+    const eventStr = `event: ${event}\n`;
+    const dataStr = `data: ${message}\n\n`;
+    return `${idStr}${eventStr}${dataStr}`;
+};
+exports.createSSEMsg = createSSEMsg;
+const createResponseMsg = (data, requestId) => {
+    const msg = {
+        Response: {
+            RequestId: requestId || (0, uuid_1.v4)(),
+            Data: data,
+        },
+    };
+    return JSON.stringify(msg);
+};

package/dist/helper/logger.d.ts

@@ -1,6 +1,5 @@
 export declare const logger: {
-    log: typeof log;
+    info: (message: unknown) => void;
+    error: (message: unknown) => void;
+    warning: (message: unknown) => void;
 };
-type LogLevel = "info" | "error" | "warning";
-declare function log(level: LogLevel, message: unknown): void;
-export {};

package/dist/helper/logger.js

@@ -4,14 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
-const moment_1 = __importDefault(require("moment"));
-exports.logger = { log };
-function log(level, message) {
-    const logTime = (0, moment_1.default)().format(`YYYY-MM-DD HH:ss:mm`);
-    if (typeof message === "object") {
-        console.log(`[${level}] - ${logTime} - ${JSON.stringify(message)}`);
+const dayjs_1 = __importDefault(require("dayjs"));
+const log = (level, message) => {
+    const logTime = (0, dayjs_1.default)().format(`YYYY-MM-DD HH:mm:ss`);
+    if (typeof message === "string") {
+        console.log(`[${level}] - [${logTime}] - ${message}`);
     }
     else {
-        console.log(`[${level}] - ${logTime} - ${message}`);
+        console.log(`[${level}] - [${logTime}] - `, message);
     }
-}
+};
+const info = (message) => log("info", message);
+const error = (message) => log("error", message);
+const warning = (message) => log("warning", message);
+exports.logger = { info, error, warning };

package/dist/helper/short-id.d.ts

@@ -0,0 +1 @@
+export declare const shortId: () => string;

package/dist/helper/short-id.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortId = void 0;
+const nanoid_1 = require("nanoid");
+const nanoid = (0, nanoid_1.customAlphabet)("123456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", 10);
+const shortId = () => nanoid();
+exports.shortId = shortId;

package/dist/helper/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/helper/sleep.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = async (ms) => new Promise((r) => setTimeout(r, ms));
+exports.sleep = sleep;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { createServer } from "./common/create-server";
 export { createErrors } from "./common/create-errors";
-export { implementAPI } from "./common/create-api";
+export { implementAPI, ServerContext } from "./common/create-api";
+export { implementSseAPI } from "./common/create-sse";
+export { callService } from "./common/call-service";

package/dist/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.implementAPI = exports.createErrors = exports.createServer = void 0;
+exports.callService = exports.implementSseAPI = exports.implementAPI = exports.createErrors = exports.createServer = void 0;
 var create_server_1 = require("./common/create-server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return create_server_1.createServer; } });
 var create_errors_1 = require("./common/create-errors");
 Object.defineProperty(exports, "createErrors", { enumerable: true, get: function () { return create_errors_1.createErrors; } });
 var create_api_1 = require("./common/create-api");
 Object.defineProperty(exports, "implementAPI", { enumerable: true, get: function () { return create_api_1.implementAPI; } });
+var create_sse_1 = require("./common/create-sse");
+Object.defineProperty(exports, "implementSseAPI", { enumerable: true, get: function () { return create_sse_1.implementSseAPI; } });
+var call_service_1 = require("./common/call-service");
+Object.defineProperty(exports, "callService", { enumerable: true, get: function () { return call_service_1.callService; } });

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "kb-server",
-  "version": "0.0.1-beta.8",
+  "version": "0.0.2-beta.1",
   "description": "A fast server for Node.JS,made by express.",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf ./dist && tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "release": "npm run build && npm publish"
   },
   "keywords": [
     "2kb",
@@ -16,14 +16,19 @@
     "dist/",
     "README.md"
   ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "author": "broxiang",
   "license": "ISC",
   "dependencies": {
+    "better-sse": "^0.13.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "dayjs": "^1.11.13",
     "express": "^4.21.1",
     "is-plain-object": "^5.0.0",
-    "moment": "^2.30.1",
+    "nanoid": "^3.3.9",
     "utility-types": "^3.11.0",
     "uuid": "^11.0.3"
   },