@lsby/net-core 0.4.0-beta.2 → 0.4.0-beta.4

package/dist/esm/{interface → interface-api}/interface-result.d.ts

@@ -11,7 +11,7 @@ declare abstract class 接口结果转换器<实现错误类型 extends ________
     protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误形式, 接口正确形式];
     abstract 实现(数据: Either<实现错误类型, 实现正确类型>): 接口错误形式 | 接口正确形式;
 }
-type 任意的接口结果转换器 = 接口结果转换器<any, any, any, any>;
+type 任意接口结果转换器 = 接口结果转换器<any, any, any, any>;
 declare class 常用形式转换器<实现错误类型 extends ________, 实现正确类型 extends ________$1> extends 接口结果转换器<实现错误类型, 实现正确类型, {
     status: 'fail';
     data: 实现错误类型;
@@ -28,4 +28,4 @@ declare class 常用形式转换器<实现错误类型 extends ________, 实现
     };
 }
 
-export { type 任意的接口结果转换器, 常用形式转换器, 接口结果转换器 };
+export { type 任意接口结果转换器, 常用形式转换器, 接口结果转换器 };

package/dist/esm/{interface → interface-api}/interface-result.js

@@ -1,7 +1,7 @@
 import {
   常用形式转换器,
   接口结果转换器
-} from "../chunk-QPKNMZKV.js";
+} from "../chunk-4HFR4KRY.js";
 export {
   \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
   \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668

package/dist/esm/{interface → interface-api}/interface-test.js

@@ -1,6 +1,6 @@
 import {
   接口测试
-} from "../chunk-N7TPWCQ5.js";
+} from "../chunk-GLZWRYH6.js";
 export {
   \u63A5\u53E3\u6D4B\u8BD5
 };

package/dist/esm/interface-table/interface-table.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { 接口逻辑 as ____ } from '../interface-api/interface-logic.js';
+import { 插件项类型 as _____ } from '../plugin/plug.js';
+import '@lsby/ts-fp-data';
+import 'express';
+
+type 基本类型 = string | number | boolean | null;
+type 条件<列名称们> = {
+    列名称: 列名称们;
+    符号: '=' | '<>';
+    值: 基本类型;
+} | {
+    列名称: 列名称们;
+    符号: '>' | '<' | '>=' | '<=';
+    值: number | string;
+} | {
+    列名称: 列名称们;
+    符号: 'like' | 'not like';
+    值: string;
+} | {
+    列名称: 列名称们;
+    符号: 'in' | 'not in';
+    值: 基本类型[];
+} | {
+    列名称: 列名称们;
+    符号: 'is' | 'is not';
+    值: 基本类型;
+};
+type 条件组<列名称们> = {
+    模式: '直接条件';
+    值: 条件<列名称们>;
+} | {
+    模式: '组合条件';
+    组合模式: '与' | '或';
+    条件们: 条件<列名称们>[];
+};
+type 扁平化条件组项<列名称们> = {
+    组合模式: '与' | '或';
+    条件: 条件<列名称们>;
+};
+type 分页选项 = {
+    页数: number;
+    大小: number;
+};
+type 排序选项<列名称们> = {
+    排序列: 列名称们;
+    排序模式: '正序' | '倒序';
+};
+type 翻译自定义类型<A> = A extends '字符串' ? string : A extends '数字' ? number : A extends '布尔' ? boolean : never;
+type 翻译列描述<对象> = {
+    [key in keyof 对象]: 翻译自定义类型<对象[key]>;
+};
+/**
+ * # 虚拟表
+ *
+ * 注意到后端大部分时候只做两件事:
+ * - 查询数据库的数据给前端
+ * - 接收前端数据, 以此更新或修改数据库的数据
+ * 甚至可以说, 后端就是提供了带鉴权的有限数据库操作机制.
+ *
+ * 同时, 注意到前端请求和修改数据是基于结构的.
+ * 例如: 前端不会要求"修改学生表的第十行的第三列的值", 而是"修改学生id为x的姓名"
+ * 注意: 前端理解的这种结构, 并不是数据库本身的结构, 而是将数据库的数据进行重组后得到的, 这个转换的过程通常由后端完成.
+ *
+ * 这样, 我们就得到了一个统一的心智模型: 后端就是对数据库结构进行重组映射, 得到前端期望的虚拟表, 同时提供模型的增删改查操作, 的逻辑集合.
+ *
+ * 我们可以抽象这个过程.
+ * 写一个"虚拟表"的抽象类.
+ * 构造这个类时需要提供构造参数, 构造参数将模型映射为一个确定的sql语句.
+ * 这个语句的结果必然是一个表, 这个表的行不确定, 但列是固定的.
+ * 这个表并不一定对应数据库里的某张表, 而是依据前端视角, 构造出来的逻辑表, 映射到数据库的一张或多张表上.
+ *
+ * 既然列已固定, 增删改查的参数和返回值就都可以确定.
+ * 当然, 并不是任何模型都可以同时提供增删改查, 如果不能提供或者不想提供, 直接报错即可.
+ *
+ * 接下来只需要继承这个类, 实现各种虚拟表即可, 注意到这些虚拟表是横向的, 可以很容易的扩展.
+ * 这样, 编写后端的过程就是编写这些虚拟表的过程, 这些模型不但简单, 也很容易扩展和管理.
+ * 我们可以很容易的编写大量的虚拟表来适配各种需求, 也很容易通过继承或组合产生新的虚拟表.
+ *
+ * 这样, 我们就将原来一个一个离散的过程式接口, 改成了对象式的虚拟表.
+ */
+declare abstract class 虚拟表<构造参数类型 extends z.AnyZodObject, 列类型 extends z.ZodObject<Record<string, z.ZodLiteral<'字符串'> | z.ZodLiteral<'数字'> | z.ZodLiteral<'布尔'>>>, 增错误 extends z.ZodEnum<[string, ...string[]]> | z.ZodNever, 删错误 extends z.ZodEnum<[string, ...string[]]> | z.ZodNever, 改错误 extends z.ZodEnum<[string, ...string[]]> | z.ZodNever, 查错误 extends z.ZodEnum<[string, ...string[]]> | z.ZodNever> {
+    protected 构造参数: z.infer<构造参数类型>;
+    static 资源路径: string;
+    protected readonly __类型保持符号?: [构造参数类型, 列类型, 增错误, 删错误, 改错误, 查错误];
+    constructor(构造参数: z.infer<构造参数类型>);
+    abstract 增(数据们: Partial<z.infer<列类型>>[]): Promise<____<_____[], {}, z.infer<增错误>, {}>>;
+    abstract 删(筛选条件?: 条件组<keyof z.infer<列类型>>): Promise<____<_____[], {}, z.infer<删错误>, {}>>;
+    abstract 改(新值: Partial<z.infer<列类型>>, 筛选条件: 条件组<keyof z.infer<列类型>>): Promise<____<_____[], {}, z.infer<改错误>, {}>>;
+    abstract 查(筛选条件?: 条件组<keyof z.infer<列类型>>, 分页条件?: 分页选项, 排序条件?: 排序选项<keyof z.infer<列类型>>): Promise<____<_____[], {}, z.infer<查错误>, 翻译列描述<z.infer<列类型>>[]>>;
+}
+type 任意虚拟表 = 虚拟表<any, any, any, any, any, any>;
+declare function 扁平化条件组<列名称们>(条件组: 条件组<列名称们>[]): 扁平化条件组项<列名称们>[];
+
+export { type 任意虚拟表, type 分页选项, type 基本类型, 扁平化条件组, type 扁平化条件组项, type 排序选项, type 条件, type 条件组, type 翻译列描述, type 翻译自定义类型, 虚拟表 };

package/dist/esm/interface-table/interface-table.js

@@ -0,0 +1,8 @@
+import {
+  扁平化条件组,
+  虚拟表
+} from "../chunk-RG6U5R37.js";
+export {
+  \u6241\u5E73\u5316\u6761\u4EF6\u7EC4,
+  \u865A\u62DF\u8868
+};

package/dist/esm/plugin/extend/chinese-path.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { 插件 as __ } from '../plug.js';
-import 'express';
 import '@lsby/ts-fp-data';
+import 'express';
 
 declare let zod类型表示: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 declare class 中文路径支持插件 extends __<typeof zod类型表示> {

package/dist/esm/plugin/extend/custom-data.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { 插件 as __ } from '../plug.js';
-import 'express';
 import '@lsby/ts-fp-data';
+import 'express';
 
 declare class 自定义数据插件<Data extends z.AnyZodObject> extends __<Data> {
     private log;

package/dist/esm/plugin/extend/custom-data.js

@@ -1,9 +1,9 @@
 import {
   自定义数据插件
-} from "../../chunk-JX5MRJL6.js";
+} from "../../chunk-43ZE4ZNH.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-BC6IISWS.js";
-import "../../chunk-EAVNASDB.js";
+import "../../chunk-DGDZQLIJ.js";
+import "../../chunk-FIQSBTYJ.js";
 export {
   \u81EA\u5B9A\u4E49\u6570\u636E\u63D2\u4EF6
 };

package/dist/esm/plugin/extend/json.js

@@ -1,10 +1,10 @@
 import {
   JSON解析插件
-} from "../../chunk-GVIGQG5Y.js";
+} from "../../chunk-IK44HWOB.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-PVE5VI5K.js";
-import "../../chunk-BC6IISWS.js";
-import "../../chunk-EAVNASDB.js";
+import "../../chunk-IGHJCQ2S.js";
+import "../../chunk-DGDZQLIJ.js";
+import "../../chunk-FIQSBTYJ.js";
 export {
   JSON\u89E3\u6790\u63D2\u4EF6
 };

package/dist/esm/plugin/extend/urlencoded.js

@@ -1,9 +1,9 @@
 import {
   表单解析插件
-} from "../../chunk-6AW5SSYA.js";
+} from "../../chunk-J5STI4LD.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-BC6IISWS.js";
-import "../../chunk-EAVNASDB.js";
+import "../../chunk-DGDZQLIJ.js";
+import "../../chunk-FIQSBTYJ.js";
 export {
   \u8868\u5355\u89E3\u6790\u63D2\u4EF6
 };

package/dist/esm/plugin/extend/web-socket.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件类型 as _Task____ } from '../plug.js';
-import 'express';
 import '@lsby/ts-fp-data';
+import 'express';
 
 declare class WebSocket插件<信息 extends z.AnyZodObject> extends __<z.ZodObject<{
     ws操作: z.ZodUnion<[
@@ -9,7 +9,7 @@ declare class WebSocket插件<信息 extends z.AnyZodObject> extends __<z.ZodObj
             发送ws信息: z.ZodFunction<z.ZodTuple<[信息], null>, z.ZodPromise<z.ZodVoid>>;
             关闭ws连接: z.ZodFunction<z.ZodTuple<[], null>, z.ZodPromise<z.ZodVoid>>;
         }>,
-        z.ZodUndefined
+        z.ZodNull
     ]>;
 }>> {
     private log;

package/dist/esm/plugin/extend/web-socket.js

@@ -1,9 +1,9 @@
 import {
   WebSocket插件
-} from "../../chunk-AVB7KPZC.js";
+} from "../../chunk-XOR7HWL4.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-BC6IISWS.js";
-import "../../chunk-EAVNASDB.js";
+import "../../chunk-DGDZQLIJ.js";
+import "../../chunk-FIQSBTYJ.js";
 export {
   WebSocket\u63D2\u4EF6
 };

package/dist/esm/plugin/plug.d.ts

@@ -1,6 +1,6 @@
+import { Task } from '@lsby/ts-fp-data';
 import { Request, Response } from 'express';
 import { z } from 'zod';
-import { Task } from '@lsby/ts-fp-data';
 
 type 插件附加参数 = {
     请求id: string;

package/dist/esm/server/server.d.ts

@@ -1,22 +1,35 @@
 import * as http from 'node:http';
-import { 任意接口 as ____ } from '../interface/interface-base.js';
+import { 任意接口 as ____ } from '../interface-api/interface-base.js';
+import { 任意虚拟表 as _____ } from '../interface-table/interface-table.js';
 import 'zod';
-import '../interface/interface-logic.js';
-import 'express';
+import '../interface-api/interface-logic.js';
 import '@lsby/ts-fp-data';
+import 'express';
 import '../plugin/plug.js';
-import '../interface/interface-result.js';
+import '../interface-api/interface-result.js';
 
 declare class 服务器 {
     private 接口们;
+    private 虚拟表们;
     private 端口;
     private 静态资源路径?;
     private log;
-    constructor(接口们: ____[], 端口: number, 静态资源路径?: string | undefined);
+    constructor(接口们: ____[], 虚拟表们: {
+        new (构造参数: any): _____;
+        资源路径: string;
+    }[], 端口: number, 静态资源路径?: string | undefined);
     run(): Promise<{
         ip: string[];
         server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     }>;
+    private 处理请求;
+    private 处理静态资源;
+    private 处理接口逻辑;
+    private 处理虚拟表逻辑;
+    private 解析虚拟表操作;
+    private 初始化WebSocket;
+    private 关闭WebSocket连接;
+    private 获取本地地址;
 }
 
 export { 服务器 };

package/dist/esm/server/server.js

@@ -1,9 +1,10 @@
 import {
   服务器
-} from "../chunk-3ERQ6GCK.js";
-import "../chunk-PVE5VI5K.js";
-import "../chunk-BC6IISWS.js";
-import "../chunk-EAVNASDB.js";
+} from "../chunk-VBCTHTJ2.js";
+import "../chunk-IGHJCQ2S.js";
+import "../chunk-DGDZQLIJ.js";
+import "../chunk-FIQSBTYJ.js";
+import "../chunk-4HFR4KRY.js";
 export {
   \u670D\u52A1\u5668
 };

package/dist/esm/tools/tools.js

@@ -1,7 +1,7 @@
 import {
   截断字符串,
   递归截断字符串
-} from "../chunk-PVE5VI5K.js";
+} from "../chunk-IGHJCQ2S.js";
 export {
   \u622A\u65AD\u5B57\u7B26\u4E32,
   \u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@lsby/net-core",
-  "version": "0.4.0-beta.2",
+  "version": "0.4.0-beta.4",
   "type": "module",
   "exports": {
     "require": "./dist/cjs/index.cjs",
     "import": "./dist/esm/index.js"
   },
   "bin": {
-    "lsby-net-core-gen-list": "./dist/bin/gen-list/bin.cjs",
-    "lsby-net-core-gen-test": "./dist/bin/gen-test/bin.cjs",
-    "lsby-net-core-gen-type": "./dist/bin/gen-type/bin.cjs"
+    "lsby-net-core-gen-api-list": "./dist/bin/gen-api-list/bin.cjs",
+    "lsby-net-core-gen-api-type": "./dist/bin/gen-api-type/bin.cjs",
+    "lsby-net-core-gen-table-list": "./dist/bin/gen-table-list/bin.cjs",
+    "lsby-net-core-gen-table-type": "./dist/bin/gen-table-type/bin.cjs",
+    "lsby-net-core-gen-test": "./dist/bin/gen-test/bin.cjs"
   },
   "files": [
     "dist"
@@ -30,7 +32,7 @@
   },
   "dependencies": {
     "@lsby/ts-global": "^0.0.5",
-    "@lsby/ts-log": "^0.0.3",
+    "@lsby/ts-log": "^0.1.0",
     "commander": "^12.1.0",
     "express": "^4.19.2",
     "lodash": "^4.17.21",
@@ -41,14 +43,22 @@
   },
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.2.1",
-    "@lsby/eslint-config": "^0.2.9",
+    "@lsby/eslint-config": "^0.2.19",
+    "@lsby/eslint-plugin": "^0.0.10",
     "@types/lodash": "^4.17.7",
     "@types/node": "^20.12.10",
     "@types/ws": "^8.5.13",
     "@vitest/coverage-v8": "^2.0.2",
     "bumpp": "^9.4.1",
-    "prettier": "3.2.5",
-    "prettier-plugin-packagejson": "^2.5.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jsdoc": "^50.2.4",
+    "eslint-plugin-react": "^7.36.1",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-sort-class-members": "^1.20.0",
+    "prettier": "3.3.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-packagejson": "^2.5.2",
     "tsup": "^8.0.2",
     "typescript": "<5.6.0"
   },

package/dist/cjs/interface/interface-logic.d.cts

@@ -1,42 +0,0 @@
-import { Request, Response } from 'express';
-import { Either } from '@lsby/ts-fp-data';
-import { 插件项类型 as _____, 合并插件结果 as ______, 插件附加参数 as ______$1 } from '../plugin/plug.cjs';
-import 'zod';
-
-type 计算混合单一组合<A, B> = A extends 接口逻辑<infer A插件类型, infer A附加参数, infer A错误, infer A返回> ? B extends 接口逻辑<infer B插件类型, infer B附加参数, infer B错误, infer B返回> ? 接口逻辑<[...A插件类型, ...B插件类型], A附加参数 & Omit<B附加参数, keyof A返回>, A错误 | B错误, A返回 & B返回> : never : never;
-type 计算混合组合数组<Arr> = Arr extends [infer x] ? x : Arr extends [infer x, infer y] ? 计算混合单一组合<x, y> : Arr extends [infer x, infer y, ...infer s] ? 计算混合组合数组<[计算混合单一组合<x, y>, ...s]> : never;
-type 接口逻辑错误类型 = string | never;
-type 接口逻辑正确类型 = Record<string, any>;
-type 接口逻辑附加参数类型 = Record<string, any>;
-/**
- * 接口逻辑的实际承担者.
- *
- * - 会被"服务器"调用, 调用时, 注入该实例的插件可以获得req和res.
- * - 插件将获取上下文的数据, 返回一个object.
- * - 所有插件被调用完成后, 合并所有结果.
- * - 然后用这个结果调用"实现", 其返回值将返回给"服务器".
- * - 返回值表示成功或失败, "服务器"会进行后续处理.
- *
- * 其中, "实现"里是真正希望接口做的事, 例如查询数据库等.
- * 而"插件"是需要的前置过程, 例如解析参数, 解析文件等.
- */
-declare abstract class 接口逻辑<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> {
-    static 混合<逻辑们 extends 任意的接口逻辑[]>(逻辑们: [...逻辑们]): 计算混合组合数组<逻辑们>;
-    static 构造<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型) => Promise<Either<错误类型, 返回类型>>): 接口逻辑<插件类型, 逻辑附加参数类型, 错误类型, 返回类型>;
-    protected readonly __类型保持符号?: [插件类型, 逻辑附加参数类型, 错误类型, 返回类型];
-    abstract 获得插件们(): [...插件类型];
-    abstract 实现(参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    运行(req: Request, res: Response, 逻辑附加参数: 逻辑附加参数类型, 插件附加参数: ______$1): Promise<Either<错误类型, 返回类型>>;
-    混合<输入的插件类型 extends _____[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型>(输入: 接口逻辑<输入的插件类型, 返回类型, 输入的错误类型, 输入的返回类型>): 接口逻辑<[
-        ...插件类型,
-        ...输入的插件类型
-    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 返回类型 & 输入的返回类型>;
-}
-type 任意的接口逻辑 = 接口逻辑<any, any, any, any>;
-type 可调用的接口逻辑 = 接口逻辑<any, Record<string, never>, any, any>;
-type 获得接口逻辑插件类型<A> = A extends 接口逻辑<infer X, any, any, any> ? X : never;
-type 获得接口逻辑附加参数类型<A> = A extends 接口逻辑<any, infer X, any, any> ? X : never;
-type 获得接口逻辑错误类型<A> = A extends 接口逻辑<any, any, infer X, any> ? X : never;
-type 获得接口逻辑正确类型<A> = A extends 接口逻辑<any, any, any, infer X> ? X : never;
-
-export { type 任意的接口逻辑, type 可调用的接口逻辑, 接口逻辑, type 接口逻辑正确类型, type 接口逻辑错误类型, type 接口逻辑附加参数类型, type 获得接口逻辑插件类型, type 获得接口逻辑正确类型, type 获得接口逻辑错误类型, type 获得接口逻辑附加参数类型 };

package/dist/esm/bin/gen-type/bin.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import {
-  main
-} from "../../chunk-BOCS6H24.js";
-import "../../chunk-KRQ6KUVY.js";
-
-// src/bin/gen-type/bin.ts
-import path from "node:path";
-import { Command } from "commander";
-var program = new Command();
-program.name("\u751F\u6210\u7C7B\u578B\u6587\u4EF6").argument("<tsconfigPath>", "tsconfig\u6587\u4EF6\u8DEF\u5F84").argument("<interfaceFolderPath>", "\u63A5\u53E3\u6587\u4EF6\u5939\u8DEF\u5F84").argument("<outFilePath>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").action(async (tsconfigPath, interfaceFolderPath, outputPath) => {
-  let absoluteTsconfigPath = path.resolve(tsconfigPath);
-  let absoluteApiFolderPath = path.resolve(interfaceFolderPath);
-  let absoluteOutputPath = path.resolve(outputPath);
-  await main(absoluteTsconfigPath, absoluteApiFolderPath, absoluteOutputPath);
-});
-program.parse(process.argv);

package/dist/esm/bin/gen-type/index.js

@@ -1,7 +0,0 @@
-import {
-  main
-} from "../../chunk-BOCS6H24.js";
-import "../../chunk-KRQ6KUVY.js";
-export {
-  main
-};

package/dist/esm/chunk-3ERQ6GCK.js

@@ -1,101 +0,0 @@
-import {
-  递归截断字符串
-} from "./chunk-PVE5VI5K.js";
-import {
-  Global
-} from "./chunk-BC6IISWS.js";
-
-// src/server/server.ts
-import { networkInterfaces } from "node:os";
-import express from "express";
-import short from "short-uuid";
-import { WebSocketServer } from "ws";
-var \u670D\u52A1\u5668 = class {
-  constructor(\u63A5\u53E3\u4EEC, \u7AEF\u53E3, \u9759\u6001\u8D44\u6E90\u8DEF\u5F84) {
-    this.\u63A5\u53E3\u4EEC = \u63A5\u53E3\u4EEC;
-    this.\u7AEF\u53E3 = \u7AEF\u53E3;
-    this.\u9759\u6001\u8D44\u6E90\u8DEF\u5F84 = \u9759\u6001\u8D44\u6E90\u8DEF\u5F84;
-  }
-  log = Global.getItem("log");
-  async run() {
-    let app = express();
-    app.use(async (req, res) => {
-      let \u8BF7\u6C42id = short().new();
-      let log = (await this.log).extend(\u8BF7\u6C42id).extend("\u63A7\u5236\u5668");
-      try {
-        let \u8BF7\u6C42\u8DEF\u5F84 = req.path;
-        let \u8BF7\u6C42\u65B9\u6CD5 = req.method.toLowerCase();
-        await log.debug("\u6536\u5230\u8BF7\u6C42, \u8DEF\u5F84: %o, \u65B9\u6CD5: %o", \u8BF7\u6C42\u8DEF\u5F84, \u8BF7\u6C42\u65B9\u6CD5);
-        await log.debug("\u5C1D\u8BD5\u5339\u914D\u63A5\u53E3...");
-        let \u76EE\u6807\u63A5\u53E3 = this.\u63A5\u53E3\u4EEC.find((\u63A5\u53E3) => {
-          let \u63A5\u53E3\u65B9\u6CD5 = \u63A5\u53E3.\u83B7\u5F97\u65B9\u6CD5();
-          let \u63A5\u53E3\u8DEF\u5F84 = \u63A5\u53E3.\u83B7\u5F97\u8DEF\u5F84();
-          return \u8BF7\u6C42\u65B9\u6CD5 == \u63A5\u53E3\u65B9\u6CD5 && \u8BF7\u6C42\u8DEF\u5F84 == \u63A5\u53E3\u8DEF\u5F84;
-        });
-        if (\u76EE\u6807\u63A5\u53E3 != null) {
-          await log.debug("\u547D\u4E2D\u63A5\u53E3");
-          let \u63A5\u53E3\u903B\u8F91 = \u76EE\u6807\u63A5\u53E3.\u83B7\u5F97\u903B\u8F91();
-          let \u63A5\u53E3\u8FD4\u56DE = \u76EE\u6807\u63A5\u53E3.\u83B7\u5F97\u7ED3\u679C\u8F6C\u6362\u5668();
-          await log.debug("\u8C03\u7528\u63A5\u53E3\u903B\u8F91...");
-          let \u63A5\u53E3\u7ED3\u679C = await \u63A5\u53E3\u903B\u8F91.\u8FD0\u884C(req, res, {}, { \u8BF7\u6C42id });
-          await log.debug("\u63A5\u53E3\u903B\u8F91\u6267\u884C\u5B8C\u6BD5");
-          await log.debug("\u51C6\u5907\u6267\u884C\u8FD4\u56DE\u903B\u8F91...");
-          let \u6700\u7EC8\u7ED3\u679C = \u63A5\u53E3\u8FD4\u56DE.\u5B9E\u73B0(\u63A5\u53E3\u7ED3\u679C);
-          await log.debug("\u8FD4\u56DE\u6570\u636E: %o", \u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32(\u6700\u7EC8\u7ED3\u679C));
-          res.send(\u6700\u7EC8\u7ED3\u679C);
-          await log.debug("\u8FD4\u56DE\u903B\u8F91\u6267\u884C\u5B8C\u6BD5");
-          return;
-        }
-        await log.debug("\u6CA1\u6709\u547D\u4E2D\u63A5\u53E3");
-        if (this.\u9759\u6001\u8D44\u6E90\u8DEF\u5F84 && req.method.toLowerCase() == "get") {
-          await log.debug("\u5C1D\u8BD5\u5339\u914D\u9759\u6001\u8D44\u6E90...");
-          express.static(this.\u9759\u6001\u8D44\u6E90\u8DEF\u5F84, {
-            setHeaders: async () => {
-              await log.debug("\u547D\u4E2D\u9759\u6001\u8D44\u6E90");
-            }
-          })(req, res, async () => {
-            await log.debug("\u6CA1\u6709\u547D\u4E2D\u9759\u6001\u8D44\u6E90");
-            await log.debug("\u6CA1\u6709\u547D\u4E2D\u4EFB\u4F55\u8D44\u6E90");
-            res.status(404);
-            res.end();
-          });
-        }
-      } catch (e) {
-        await log.err(e);
-        res.status(500);
-        res.send("\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
-      }
-    });
-    let server = app.listen(this.\u7AEF\u53E3);
-    let wss = new WebSocketServer({ server });
-    wss.on("connection", async (ws, req) => {
-      let log = (await this.log).extend(short().new()).extend("WebSocket");
-      await log.debug(`WebSocket \u8BF7\u6C42\u8FDE\u63A5: ${req.url}`);
-      let WebSocket\u7BA1\u7406\u8005 = await Global.getItem("WebSocket\u7BA1\u7406\u8005");
-      let \u5BA2\u6237\u7AEFid = req.url?.split("?id=")[1];
-      if (!\u5BA2\u6237\u7AEFid)
-        return ws.close(4001, "\u7F3A\u5C11\u5BA2\u6237\u7AEF ID");
-      if (await WebSocket\u7BA1\u7406\u8005.\u67E5\u8BE2\u8FDE\u63A5\u5B58\u5728(\u5BA2\u6237\u7AEFid) == true)
-        return ws.close(4002, "\u5BA2\u6237\u7AEF ID \u5DF2\u5B58\u5728");
-      let \u5B58\u5728\u7684\u5BA2\u6237\u7AEFid = \u5BA2\u6237\u7AEFid;
-      await WebSocket\u7BA1\u7406\u8005.\u589E\u52A0\u8FDE\u63A5(\u5BA2\u6237\u7AEFid, ws);
-      await log.debug(`WebSocket \u8FDE\u63A5\u5DF2\u5EFA\u7ACB, \u5BA2\u6237\u7AEFid: ${\u5BA2\u6237\u7AEFid}`);
-      ws.on("close", async () => {
-        await log.debug(`WebSocket \u8FDE\u63A5\u5DF2\u5173\u95ED: ${\u5BA2\u6237\u7AEFid}`);
-        await WebSocket\u7BA1\u7406\u8005.\u5220\u9664\u8FDE\u63A5(\u5B58\u5728\u7684\u5BA2\u6237\u7AEFid);
-      });
-      ws.on("error", async (err) => {
-        await log.err(`WebSocket \u51FA\u73B0\u9519\u8BEF ${\u5BA2\u6237\u7AEFid}: %o`, err);
-        await WebSocket\u7BA1\u7406\u8005.\u5220\u9664\u8FDE\u63A5(\u5B58\u5728\u7684\u5BA2\u6237\u7AEFid);
-      });
-    });
-    return {
-      ip: Object.values(networkInterfaces()).flat().flatMap((address) => address !== void 0 ? [address] : []).map((wrappedAddress) => wrappedAddress.address).map((address) => `http://${address}:${this.\u7AEF\u53E3}`),
-      server
-    };
-  }
-};
-
-export {
-  服务器
-};

package/dist/esm/interface/interface-logic.d.ts

@@ -1,42 +0,0 @@
-import { Request, Response } from 'express';
-import { Either } from '@lsby/ts-fp-data';
-import { 插件项类型 as _____, 合并插件结果 as ______, 插件附加参数 as ______$1 } from '../plugin/plug.js';
-import 'zod';
-
-type 计算混合单一组合<A, B> = A extends 接口逻辑<infer A插件类型, infer A附加参数, infer A错误, infer A返回> ? B extends 接口逻辑<infer B插件类型, infer B附加参数, infer B错误, infer B返回> ? 接口逻辑<[...A插件类型, ...B插件类型], A附加参数 & Omit<B附加参数, keyof A返回>, A错误 | B错误, A返回 & B返回> : never : never;
-type 计算混合组合数组<Arr> = Arr extends [infer x] ? x : Arr extends [infer x, infer y] ? 计算混合单一组合<x, y> : Arr extends [infer x, infer y, ...infer s] ? 计算混合组合数组<[计算混合单一组合<x, y>, ...s]> : never;
-type 接口逻辑错误类型 = string | never;
-type 接口逻辑正确类型 = Record<string, any>;
-type 接口逻辑附加参数类型 = Record<string, any>;
-/**
- * 接口逻辑的实际承担者.
- *
- * - 会被"服务器"调用, 调用时, 注入该实例的插件可以获得req和res.
- * - 插件将获取上下文的数据, 返回一个object.
- * - 所有插件被调用完成后, 合并所有结果.
- * - 然后用这个结果调用"实现", 其返回值将返回给"服务器".
- * - 返回值表示成功或失败, "服务器"会进行后续处理.
- *
- * 其中, "实现"里是真正希望接口做的事, 例如查询数据库等.
- * 而"插件"是需要的前置过程, 例如解析参数, 解析文件等.
- */
-declare abstract class 接口逻辑<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> {
-    static 混合<逻辑们 extends 任意的接口逻辑[]>(逻辑们: [...逻辑们]): 计算混合组合数组<逻辑们>;
-    static 构造<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型) => Promise<Either<错误类型, 返回类型>>): 接口逻辑<插件类型, 逻辑附加参数类型, 错误类型, 返回类型>;
-    protected readonly __类型保持符号?: [插件类型, 逻辑附加参数类型, 错误类型, 返回类型];
-    abstract 获得插件们(): [...插件类型];
-    abstract 实现(参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    运行(req: Request, res: Response, 逻辑附加参数: 逻辑附加参数类型, 插件附加参数: ______$1): Promise<Either<错误类型, 返回类型>>;
-    混合<输入的插件类型 extends _____[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型>(输入: 接口逻辑<输入的插件类型, 返回类型, 输入的错误类型, 输入的返回类型>): 接口逻辑<[
-        ...插件类型,
-        ...输入的插件类型
-    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 返回类型 & 输入的返回类型>;
-}
-type 任意的接口逻辑 = 接口逻辑<any, any, any, any>;
-type 可调用的接口逻辑 = 接口逻辑<any, Record<string, never>, any, any>;
-type 获得接口逻辑插件类型<A> = A extends 接口逻辑<infer X, any, any, any> ? X : never;
-type 获得接口逻辑附加参数类型<A> = A extends 接口逻辑<any, infer X, any, any> ? X : never;
-type 获得接口逻辑错误类型<A> = A extends 接口逻辑<any, any, infer X, any> ? X : never;
-type 获得接口逻辑正确类型<A> = A extends 接口逻辑<any, any, any, infer X> ? X : never;
-
-export { type 任意的接口逻辑, type 可调用的接口逻辑, 接口逻辑, type 接口逻辑正确类型, type 接口逻辑错误类型, type 接口逻辑附加参数类型, type 获得接口逻辑插件类型, type 获得接口逻辑正确类型, type 获得接口逻辑错误类型, type 获得接口逻辑附加参数类型 };

package/dist/esm/interface/interface-logic.js

@@ -1,8 +0,0 @@
-import {
-  接口逻辑
-} from "../chunk-EZ7OJFSQ.js";
-import "../chunk-BC6IISWS.js";
-import "../chunk-EAVNASDB.js";
-export {
-  \u63A5\u53E3\u903B\u8F91
-};