@lsby/net-core 0.3.44 → 0.4.0-beta.10

package/dist/cjs/index.d.cts

@@ -1,16 +1,17 @@
 export { 业务行为, 业务行为参数类型, 业务行为返回类型, 业务行为错误类型, 计算业务行为参数, 计算业务行为返回, 计算业务行为错误 } from './action/action.cjs';
-export { JSON接口 } from './interface/extend/json-base.cjs';
-export { JSON状态接口, JSON状态接口类型 } from './interface/extend/json-wrap.cjs';
-export { 任意接口, 接口, 计算接口参数, 计算接口返回 } from './interface/interface-inst.cjs';
-export { 接口测试 } from './interface/interface-test.cjs';
-export { 任意接口类型, 接口类型, 接口类型插件们, 接口类型方法, 接口类型正确结果, 接口类型路径, 接口类型错误结果, 获得接口插件们 } from './interface/interface-type.cjs';
+export { 任意接口, 接口, 接口方法类型, 接口路径类型, 获得接口方法类型, 获得接口正确形式, 获得接口结果转换器类型, 获得接口路径类型, 获得接口逻辑类型, 获得接口错误形式 } from './interface-api/interface-base.cjs';
+export { 任意接口逻辑, 可调用接口逻辑, 接口逻辑, 接口逻辑正确类型, 接口逻辑错误类型, 接口逻辑附加参数类型, 获得接口逻辑插件类型, 获得接口逻辑正确类型, 获得接口逻辑错误类型, 获得接口逻辑附加参数类型 } from './interface-api/interface-logic.cjs';
+export { 任意接口结果转换器, 常用形式转换器, 接口结果转换器 } from './interface-api/interface-result.cjs';
+export { 接口测试 } from './interface-api/interface-test.cjs';
+export { 任意虚拟表, 分页选项, 排序选项, 是any, 条件, 条件组, 翻译列描述, 翻译列描述带空, 翻译自定义类型, 虚拟表 } from './interface-table/interface-table.cjs';
 export { 中文路径支持插件 } from './plugin/extend/chinese-path.cjs';
 export { 自定义数据插件 } from './plugin/extend/custom-data.cjs';
-export { JSON解析插件, 从接口类型获得JSON参数, 任意JSON解析插件, 任意JSON解析插件项, 合并JSON插件结果 } from './plugin/extend/json.cjs';
+export { JSON解析插件, 任意JSON解析插件, 任意JSON解析插件项, 合并JSON插件结果 } from './plugin/extend/json.cjs';
 export { 表单解析插件 } from './plugin/extend/urlencoded.cjs';
 export { WebSocket插件, 任意WS插件, 任意WS插件项, 取WS插件泛型, 取第一个WS插件结果 } from './plugin/extend/web-socket.cjs';
-export { 任意插件, 包装插件项, 取Task插件内部类型, 取Task插件类型, 取插件内部ts类型, 合并插件结果, 插件, 插件项类型, 附加参数类型 } from './plugin/plug.cjs';
-export { 正确JSON结果, 正确结果, 正确自定义结果, 结果, 错误JSON结果, 错误结果 } from './result/result.cjs';
+export { 任意插件, 包装插件项, 取Task插件内部类型, 取Task插件类型, 取插件内部ts类型, 合并插件结果, 插件, 插件附加参数, 插件项类型 } from './plugin/plug.cjs';
+export { 截断字符串, 递归截断字符串 } from './tools/tools.cjs';
+export { 去除只读 } from './tools/types.cjs';
 export { 服务器 } from './server/server.cjs';
 import '@lsby/ts-fp-data';
 import 'zod';

package/dist/cjs/interface-api/interface-base.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interface-api/interface-base.ts
+var interface_base_exports = {};
+__export(interface_base_exports, {
+  \u63A5\u53E3: () => \u63A5\u53E3
+});
+module.exports = __toCommonJS(interface_base_exports);
+var \u63A5\u53E3 = class {
+  constructor(\u8BF7\u6C42\u8DEF\u5F84, \u8BF7\u6C42\u65B9\u6CD5, \u63A5\u53E3\u903B\u8F91, \u63A5\u53E3\u9519\u8BEF\u5F62\u5F0FZod, \u63A5\u53E3\u6B63\u786E\u5F62\u5F0FZod, \u7ED3\u679C\u8F6C\u6362\u5668) {
+    this.\u8BF7\u6C42\u8DEF\u5F84 = \u8BF7\u6C42\u8DEF\u5F84;
+    this.\u8BF7\u6C42\u65B9\u6CD5 = \u8BF7\u6C42\u65B9\u6CD5;
+    this.\u63A5\u53E3\u903B\u8F91 = \u63A5\u53E3\u903B\u8F91;
+    this.\u63A5\u53E3\u9519\u8BEF\u5F62\u5F0FZod = \u63A5\u53E3\u9519\u8BEF\u5F62\u5F0FZod;
+    this.\u63A5\u53E3\u6B63\u786E\u5F62\u5F0FZod = \u63A5\u53E3\u6B63\u786E\u5F62\u5F0FZod;
+    this.\u7ED3\u679C\u8F6C\u6362\u5668 = \u7ED3\u679C\u8F6C\u6362\u5668;
+  }
+  \u83B7\u5F97\u8DEF\u5F84() {
+    return this.\u8BF7\u6C42\u8DEF\u5F84;
+  }
+  \u83B7\u5F97\u65B9\u6CD5() {
+    return this.\u8BF7\u6C42\u65B9\u6CD5;
+  }
+  \u83B7\u5F97\u903B\u8F91() {
+    return this.\u63A5\u53E3\u903B\u8F91;
+  }
+  \u83B7\u5F97\u63A5\u53E3\u9519\u8BEF\u5F62\u5F0FZod() {
+    return this.\u63A5\u53E3\u9519\u8BEF\u5F62\u5F0FZod;
+  }
+  \u83B7\u5F97\u63A5\u53E3\u6B63\u786E\u5F62\u5F0FZod() {
+    return this.\u63A5\u53E3\u6B63\u786E\u5F62\u5F0FZod;
+  }
+  \u83B7\u5F97\u7ED3\u679C\u8F6C\u6362\u5668() {
+    return this.\u7ED3\u679C\u8F6C\u6362\u5668;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  \u63A5\u53E3
+});

package/dist/cjs/interface-api/interface-base.d.cts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { 可调用接口逻辑 as _______, 获得接口逻辑错误类型 as __________, 获得接口逻辑正确类型 as __________$1 } from './interface-logic.cjs';
+import { 接口结果转换器 as _______$1 } from './interface-result.cjs';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../plugin/plug.cjs';
+
+type 接口路径类型 = string;
+type 接口方法类型 = 'get' | 'post';
+/**
+ * 接口的描述.
+ */
+declare class 接口<路径类型 extends 接口路径类型, 方法类型 extends 接口方法类型, 逻辑类型 extends _______, 接口错误形式Zod extends z.ZodTypeAny, 接口正确形式Zod extends z.ZodTypeAny, 接口结果转换器类型 extends _______$1<__________<逻辑类型>, __________$1<逻辑类型>, z.infer<接口错误形式Zod>, z.infer<接口正确形式Zod>>> {
+    private 请求路径;
+    private 请求方法;
+    private 接口逻辑;
+    private 接口错误形式Zod;
+    private 接口正确形式Zod;
+    private 结果转换器;
+    protected readonly __类型保持符号?: [
+        路径类型,
+        方法类型,
+        逻辑类型,
+        接口错误形式Zod,
+        接口正确形式Zod,
+        接口结果转换器类型
+    ];
+    constructor(请求路径: 路径类型, 请求方法: 方法类型, 接口逻辑: 逻辑类型, 接口错误形式Zod: 接口错误形式Zod, 接口正确形式Zod: 接口正确形式Zod, 结果转换器: 接口结果转换器类型);
+    获得路径(): 路径类型;
+    获得方法(): 方法类型;
+    获得逻辑(): 逻辑类型;
+    获得接口错误形式Zod(): 接口错误形式Zod;
+    获得接口正确形式Zod(): 接口正确形式Zod;
+    获得结果转换器(): 接口结果转换器类型;
+}
+type 任意接口 = 接口<any, any, any, any, any, any>;
+type 获得接口路径类型<A> = A extends 接口<infer X, any, any, any, any, any> ? X : never;
+type 获得接口方法类型<A> = A extends 接口<any, infer X, any, any, any, any> ? X : never;
+type 获得接口逻辑类型<A> = A extends 接口<any, any, infer X, any, any, any> ? X : never;
+type 获得接口错误形式<A> = A extends 接口<any, any, any, infer X, any, any> ? z.infer<X> : never;
+type 获得接口正确形式<A> = A extends 接口<any, any, any, any, infer X, any> ? z.infer<X> : never;
+type 获得接口结果转换器类型<A> = A extends 接口<any, any, any, any, any, infer X> ? X : never;
+
+export { type 任意接口, 接口, type 接口方法类型, type 接口路径类型, type 获得接口方法类型, type 获得接口正确形式, type 获得接口结果转换器类型, type 获得接口路径类型, type 获得接口逻辑类型, type 获得接口错误形式 };

package/dist/cjs/interface-api/interface-logic.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interface-api/interface-logic.ts
+var interface_logic_exports = {};
+__export(interface_logic_exports, {
+  \u63A5\u53E3\u903B\u8F91: () => \u63A5\u53E3\u903B\u8F91
+});
+module.exports = __toCommonJS(interface_logic_exports);
+
+// src/global/global.ts
+var import_ts_global = require("@lsby/ts-global");
+var import_ts_log = require("@lsby/ts-log");
+
+// src/global/ws.ts
+var WebSocket\u7BA1\u7406\u8005 = class {
+  constructor(\u8FDE\u63A5\u8868) {
+    this.\u8FDE\u63A5\u8868 = \u8FDE\u63A5\u8868;
+  }
+  async \u589E\u52A0\u8FDE\u63A5(\u8BF7\u6C42id, ws\u53E5\u67C4) {
+    this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] = ws\u53E5\u67C4;
+  }
+  async \u67E5\u8BE2\u8FDE\u63A5\u5B58\u5728(\u8BF7\u6C42id) {
+    return this.\u8FDE\u63A5\u8868.hasOwnProperty(\u8BF7\u6C42id) ? true : false;
+  }
+  async \u83B7\u5F97\u53E5\u67C4(\u8BF7\u6C42id) {
+    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] ?? null;
+  }
+  async \u5220\u9664\u8FDE\u63A5(id) {
+    delete this.\u8FDE\u63A5\u8868[id];
+  }
+};
+
+// src/global/global.ts
+var Global = new import_ts_global.GlobalService([
+  new import_ts_global.GlobalAsyncItem("log", async () => {
+    return new import_ts_log.Log("@lsby:net-core");
+  }),
+  new import_ts_global.GlobalAsyncItem("WebSocket\u7BA1\u7406\u8005", async () => {
+    return new WebSocket\u7BA1\u7406\u8005({});
+  })
+]);
+
+// src/interface-api/interface-logic.ts
+var \u63A5\u53E3\u903B\u8F91 = class _\u63A5\u53E3\u903B\u8F91 {
+  static \u6DF7\u5408(\u903B\u8F91\u4EEC) {
+    return \u903B\u8F91\u4EEC.reduce((s, a) => s.\u6DF7\u5408(a));
+  }
+  static \u6784\u9020(\u63D2\u4EF6\u4EEC, \u5B9E\u73B0, \u903B\u8F91\u9644\u52A0\u53C2\u6570) {
+    let c = new class extends _\u63A5\u53E3\u903B\u8F91 {
+      \u83B7\u5F97\u63D2\u4EF6\u4EEC() {
+        return \u63D2\u4EF6\u4EEC;
+      }
+      \u5B9E\u73B0(\u53C2\u6570, \u903B\u8F91\u9644\u52A0\u53C2\u65702) {
+        return \u5B9E\u73B0(\u53C2\u6570, \u903B\u8F91\u9644\u52A0\u53C2\u65702);
+      }
+    }();
+    c.\u5185\u90E8\u7684\u903B\u8F91\u9644\u52A0\u53C2\u6570 = \u903B\u8F91\u9644\u52A0\u53C2\u6570 ?? {};
+    return c;
+  }
+  \u5185\u90E8\u7684\u903B\u8F91\u9644\u52A0\u53C2\u6570 = {};
+  \u8BBE\u7F6E\u903B\u8F91\u9644\u52A0\u53C2\u6570(\u8BBE\u7F6E\u53C2\u6570) {
+    return _\u63A5\u53E3\u903B\u8F91.\u6784\u9020(this.\u83B7\u5F97\u63D2\u4EF6\u4EEC(), this.\u5B9E\u73B0, \u8BBE\u7F6E\u53C2\u6570);
+  }
+  async \u8FD0\u884C(req, res, \u4F20\u5165\u7684\u903B\u8F91\u9644\u52A0\u53C2\u6570, \u4F20\u5165\u7684\u63D2\u4EF6\u9644\u52A0\u53C2\u6570) {
+    let log = (await Global.getItem("log")).extend(\u4F20\u5165\u7684\u63D2\u4EF6\u9644\u52A0\u53C2\u6570.\u8BF7\u6C42id).extend("\u63A5\u53E3\u903B\u8F91");
+    let \u63D2\u4EF6\u4EEC = this.\u83B7\u5F97\u63D2\u4EF6\u4EEC();
+    await log.debug("\u627E\u5230 %o \u4E2A \u63D2\u4EF6, \u51C6\u5907\u6267\u884C...", \u63D2\u4EF6\u4EEC.length);
+    let \u6240\u6709\u63D2\u4EF6\u7ED3\u679C = [];
+    for (let \u63D2\u4EF6 of \u63D2\u4EF6\u4EEC) {
+      let \u63D2\u4EF6\u672C\u4F53 = await \u63D2\u4EF6.run();
+      let \u63D2\u4EF6\u8FD4\u56DE = await \u63D2\u4EF6\u672C\u4F53.\u8FD0\u884C(req, res, \u4F20\u5165\u7684\u63D2\u4EF6\u9644\u52A0\u53C2\u6570);
+      \u6240\u6709\u63D2\u4EF6\u7ED3\u679C.push(\u63D2\u4EF6\u8FD4\u56DE);
+    }
+    let \u5408\u5E76\u63D2\u4EF6\u7ED3\u679C = \u6240\u6709\u63D2\u4EF6\u7ED3\u679C.reduce((s, a) => Object.assign(s, a), {});
+    await log.debug("\u63D2\u4EF6 \u6267\u884C\u5B8C\u6BD5");
+    await log.debug("\u51C6\u5907\u6267\u884C\u63A5\u53E3\u5B9E\u73B0...");
+    let \u5B9E\u73B0\u7ED3\u679C = await this.\u5B9E\u73B0(\u5408\u5E76\u63D2\u4EF6\u7ED3\u679C, Object.assign(this.\u5185\u90E8\u7684\u903B\u8F91\u9644\u52A0\u53C2\u6570, \u4F20\u5165\u7684\u903B\u8F91\u9644\u52A0\u53C2\u6570));
+    await log.debug("\u63A5\u53E3\u5B9E\u73B0\u6267\u884C\u5B8C\u6BD5");
+    return \u5B9E\u73B0\u7ED3\u679C;
+  }
+  \u6DF7\u5408(\u8F93\u5165) {
+    let self = this;
+    return _\u63A5\u53E3\u903B\u8F91.\u6784\u9020([...this.\u83B7\u5F97\u63D2\u4EF6\u4EEC(), ...\u8F93\u5165.\u83B7\u5F97\u63D2\u4EF6\u4EEC()], async (\u53C2\u6570, \u903B\u8F91\u9644\u52A0\u53C2\u6570) => {
+      let c = await self.\u5B9E\u73B0(\u53C2\u6570, \u903B\u8F91\u9644\u52A0\u53C2\u6570);
+      if (c.isLeft())
+        return c;
+      return await \u8F93\u5165.\u5B9E\u73B0(\u53C2\u6570, Object.assign(\u903B\u8F91\u9644\u52A0\u53C2\u6570, c.assertRight().getRight()));
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  \u63A5\u53E3\u903B\u8F91
+});

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

@@ -0,0 +1,61 @@
+import { Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+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>;
+/**
+ * # 接口逻辑的基础抽象类
+ *
+ * - 该类表示一个接口的逻辑执行过程, 包括插件的运行, 结果的合并以及业务逻辑的实际执行.
+ * - 插件提供预处理功能, 例如参数解析等, 它通过解析express的上下文, 获得结果并提供给实现.
+ * - 实现函数负责业务逻辑的主要操作, 例如数据库查询等, 它接收插件的处理结果, 并返回计算结果(用Either表示).
+ * - 运行时除了获得express上下文外, 还可以接收自定义参数, 称为`逻辑附加参数`.
+ * - 每个接口逻辑实例可以通过一些方法与其他接口逻辑合并, 形成一个复杂的流程.
+ *
+ * ## 构造:
+ *
+ * - 可以通过继承该抽象类, 并实现抽象函数来使用.
+ * - 也可以通过静态方法`构造`来直接进行构造.
+ *
+ * ## 组合
+ *
+ * 通过组合, 可以将简单的逻辑模块化, 并按需构建复杂的接口处理流程.
+ *
+ * ### 混合
+ *
+ * - 该类提供了`混合`方法, 用于将多个接口逻辑实例合成一个复合接口逻辑.
+ *   - 组合的接口逻辑会按顺序依次被调用.
+ *   - 如果某接口逻辑返回左值, 则整个结构将立即返回该左值.
+ *   - 否则, 将右值内容注入上下文, 允许之后的接口逻辑通过`逻辑附加参数`访问它.
+ *   - 最终将返回最后一个接口逻辑的运行结果.
+ * - 这类似于monad的do结构, 在该结构中, 每个运行结果都会被注入到全局上下文并消除monad包装, 而语句可以使用上下文的值.
+ *
+ * ### 其他组合方法用到再写
+ */
+declare abstract class 接口逻辑<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> {
+    static 混合<逻辑们 extends 任意接口逻辑[]>(逻辑们: [...逻辑们]): 计算混合组合数组<逻辑们>;
+    static 构造<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型) => Promise<Either<错误类型, 返回类型>>, 逻辑附加参数?: Partial<逻辑附加参数类型> | undefined): 接口逻辑<插件类型, 逻辑附加参数类型, 错误类型, 返回类型>;
+    private 内部的逻辑附加参数;
+    protected readonly __类型保持符号?: [插件类型, 逻辑附加参数类型, 错误类型, 返回类型];
+    abstract 获得插件们(): [...插件类型];
+    abstract 实现(参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型): Promise<Either<错误类型, 返回类型>>;
+    设置逻辑附加参数<A extends Partial<逻辑附加参数类型>>(设置参数: A): 接口逻辑<插件类型, Omit<逻辑附加参数类型, keyof A>, 错误类型, 返回类型>;
+    运行(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/cjs/interface-api/interface-result.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interface-api/interface-result.ts
+var interface_result_exports = {};
+__export(interface_result_exports, {
+  \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668: () => \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
+  \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668: () => \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668
+});
+module.exports = __toCommonJS(interface_result_exports);
+var \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668 = class {
+};
+var \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668 = class extends \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668 {
+  \u5B9E\u73B0(\u6570\u636E) {
+    switch (\u6570\u636E.getTag()) {
+      case "Left": {
+        return { status: "fail", data: \u6570\u636E.assertLeft().getLeft() };
+      }
+      case "Right": {
+        return { status: "success", data: \u6570\u636E.assertRight().getRight() };
+      }
+      default: {
+        throw new Error("\u610F\u5916\u7684\u6570\u636E\u6807\u8BB0");
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
+  \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668
+});

package/dist/cjs/interface-api/interface-result.d.cts

@@ -0,0 +1,31 @@
+import { Either } from '@lsby/ts-fp-data';
+import { 接口逻辑错误类型 as ________, 接口逻辑正确类型 as ________$1 } from './interface-logic.cjs';
+import 'express';
+import '../plugin/plug.cjs';
+import 'zod';
+
+/**
+ * 描述接口逻辑返回的数据将以何种形式返回给前端.
+ */
+declare abstract class 接口结果转换器<实现错误类型 extends ________, 实现正确类型 extends ________$1, 接口错误形式, 接口正确形式> {
+    protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误形式, 接口正确形式];
+    abstract 实现(数据: Either<实现错误类型, 实现正确类型>): 接口错误形式 | 接口正确形式;
+}
+type 任意接口结果转换器 = 接口结果转换器<any, any, any, any>;
+declare class 常用形式转换器<实现错误类型 extends ________, 实现正确类型 extends ________$1> extends 接口结果转换器<实现错误类型, 实现正确类型, {
+    status: 'fail';
+    data: 实现错误类型;
+}, {
+    status: 'success';
+    data: 实现正确类型;
+}> {
+    实现(数据: Either<实现错误类型, 实现正确类型>): {
+        status: 'fail';
+        data: 实现错误类型;
+    } | {
+        status: 'success';
+        data: 实现正确类型;
+    };
+}
+
+export { type 任意接口结果转换器, 常用形式转换器, 接口结果转换器 };

package/dist/cjs/{interface → interface-api}/interface-test.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/interface/interface-test.ts
+// src/interface-api/interface-test.ts
 var interface_test_exports = {};
 __export(interface_test_exports, {
   \u63A5\u53E3\u6D4B\u8BD5: () => \u63A5\u53E3\u6D4B\u8BD5

package/dist/cjs/interface-table/interface-table.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interface-table/interface-table.ts
+var interface_table_exports = {};
+__export(interface_table_exports, {
+  \u865A\u62DF\u8868: () => \u865A\u62DF\u8868
+});
+module.exports = __toCommonJS(interface_table_exports);
+var \u865A\u62DF\u8868 = class {
+  constructor(\u6784\u9020\u53C2\u6570) {
+    this.\u6784\u9020\u53C2\u6570 = \u6784\u9020\u53C2\u6570;
+  }
+  static \u8D44\u6E90\u8DEF\u5F84;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  \u865A\u62DF\u8868
+});

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

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { 接口逻辑 as ____ } from '../interface-api/interface-logic.cjs';
+import { 插件项类型 as _____ } from '../plugin/plug.cjs';
+import '@lsby/ts-fp-data';
+import 'express';
+
+type 是any<T> = 0 extends 1 & T ? true : false;
+type 条件<列定义> = 是any<列定义> extends true ? any : {
+    [K in keyof 列定义]: {
+        列: K;
+        符号: '=' | '<>';
+        值: 列定义[K];
+    };
+}[keyof 列定义] | {
+    [K in keyof 列定义]: {
+        列: K;
+        符号: 'in' | 'not in';
+        值: 列定义[K][];
+    };
+}[keyof 列定义] | {
+    [K in keyof 列定义]: {
+        列: K;
+        符号: 'is' | 'is not';
+        值: null;
+    };
+}[keyof 列定义] | {
+    [K in keyof 列定义]: 列定义[K] extends string ? {
+        列: K;
+        符号: 'like' | 'not like';
+        值: string;
+    } : never;
+}[keyof 列定义] | {
+    [K in keyof 列定义]: 列定义[K] extends number ? {
+        列: K;
+        符号: '>' | '<' | '>=' | '<=';
+        值: number;
+    } : never;
+}[keyof 列定义];
+type 条件组<列定义 extends object> = 条件<列定义>[];
+type 分页选项 = {
+    页数: number;
+    大小: number;
+};
+type 排序选项<列名称们> = {
+    排序列: 列名称们;
+    排序模式: '正序' | '倒序';
+};
+type 翻译自定义类型<A> = A extends '字符串' ? string : A extends '数字' ? number : A extends '布尔' ? boolean : never;
+type 翻译列描述<对象> = 是any<对象> extends true ? any : {
+    [key in keyof 对象]: 翻译自定义类型<对象[key]>;
+};
+type 翻译列描述带空<对象> = 是any<对象> extends true ? any : {
+    [key in keyof 对象]: 翻译自定义类型<对象[key]> | undefined;
+};
+/**
+ * # 虚拟表
+ *
+ * 注意到后端大部分时候只做两件事:
+ * - 查询数据库的数据给前端
+ * - 接收前端数据, 以此更新或修改数据库的数据
+ * 甚至可以说, 后端就是提供了带鉴权的有限数据库操作机制.
+ *
+ * 同时, 注意到前端请求和修改数据是基于结构的.
+ * 例如: 前端不会要求"修改学生表的第十行的第三列的值", 而是"修改学生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 删(筛选条件: 条件组<翻译列描述<z.infer<列类型>>>): Promise<____<_____[], {}, z.infer<删错误>, {}>>;
+    abstract 改(新值: Partial<z.infer<列类型>>, 筛选条件: 条件组<翻译列描述<z.infer<列类型>>>): Promise<____<_____[], {}, z.infer<改错误>, {}>>;
+    abstract 查(筛选条件?: 条件组<翻译列描述<z.infer<列类型>>>, 分页条件?: 分页选项, 排序条件?: 排序选项<keyof z.infer<列类型>>): Promise<____<_____[], {}, z.infer<查错误>, 翻译列描述带空<z.infer<列类型>>[]>>;
+}
+type 任意虚拟表 = 虚拟表<any, any, any, any, any, any>;
+
+export { type 任意虚拟表, type 分页选项, type 排序选项, type 是any, type 条件, type 条件组, type 翻译列描述, type 翻译列描述带空, type 翻译自定义类型, 虚拟表 };

package/dist/cjs/plugin/extend/chinese-path.d.cts

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

package/dist/cjs/plugin/extend/custom-data.cjs

@@ -37,10 +37,10 @@ var WebSocket\u7BA1\u7406\u8005 = class {
     this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] = ws\u53E5\u67C4;
   }
   async \u67E5\u8BE2\u8FDE\u63A5\u5B58\u5728(\u8BF7\u6C42id) {
-    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] == null ? false : true;
+    return this.\u8FDE\u63A5\u8868.hasOwnProperty(\u8BF7\u6C42id) ? true : false;
   }
   async \u83B7\u5F97\u53E5\u67C4(\u8BF7\u6C42id) {
-    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] || null;
+    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] ?? null;
   }
   async \u5220\u9664\u8FDE\u63A5(id) {
     delete this.\u8FDE\u63A5\u8868[id];

package/dist/cjs/plugin/extend/custom-data.d.cts

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

package/dist/cjs/plugin/extend/json.cjs

@@ -33,8 +33,8 @@ __export(json_exports, {
   JSON\u89E3\u6790\u63D2\u4EF6: () => JSON\u89E3\u6790\u63D2\u4EF6
 });
 module.exports = __toCommonJS(json_exports);
-var import_node_util = require("util");
 var import_express = __toESM(require("express"), 1);
+var import_node_util = require("util");
 
 // src/global/global.ts
 var import_ts_global = require("@lsby/ts-global");
@@ -49,10 +49,10 @@ var WebSocket\u7BA1\u7406\u8005 = class {
     this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] = ws\u53E5\u67C4;
   }
   async \u67E5\u8BE2\u8FDE\u63A5\u5B58\u5728(\u8BF7\u6C42id) {
-    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] == null ? false : true;
+    return this.\u8FDE\u63A5\u8868.hasOwnProperty(\u8BF7\u6C42id) ? true : false;
   }
   async \u83B7\u5F97\u53E5\u67C4(\u8BF7\u6C42id) {
-    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] || null;
+    return this.\u8FDE\u63A5\u8868[\u8BF7\u6C42id] ?? null;
   }
   async \u5220\u9664\u8FDE\u63A5(id) {
     delete this.\u8FDE\u63A5\u8868[id];
@@ -84,7 +84,7 @@ function \u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32(\u6570\u636E) {
   if (typeof \u6570\u636E === "object" && \u6570\u636E !== null) {
     let \u65B0\u6570\u636E = {};
     for (let key in \u6570\u636E) {
-      if (\u6570\u636E.hasOwnProperty(key))
+      if (\u6570\u636E.hasOwnProperty(key) === true)
         \u65B0\u6570\u636E[key] = \u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32(\u6570\u636E[key]);
     }
     return \u65B0\u6570\u636E;
@@ -119,9 +119,9 @@ var JSON\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
       );
       await log.debug("\u51C6\u5907\u89E3\u6790 JSON\uFF1A%o", \u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32(req.body));
       let parseResult = t.safeParse(req.body);
-      if (!parseResult.success) {
-        await log.err("\u89E3\u6790 JSON \u5931\u8D25\uFF1A%o", parseResult.error);
-        throw new Error((0, import_node_util.format)("\u89E3\u6790 JSON \u5931\u8D25: %O", parseResult.error));
+      if (parseResult.success === false) {
+        await log.error("\u89E3\u6790 JSON \u5931\u8D25\uFF1A%o", parseResult.error);
+        throw new Error((0, import_node_util.format)("\u89E3\u6790 JSON \u5931\u8D25: %o", parseResult.error));
       }
       await log.debug("\u6210\u529F\u89E3\u6790 JSON");
       return parseResult.data;

package/dist/cjs/plugin/extend/json.d.cts

@@ -1,7 +1,6 @@
 import express from 'express';
 import { AnyZodObject, z } from 'zod';
-import { 获得接口插件们 as _______ } from '../../interface/interface-type.cjs';
-import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件内部类型 as _Task______, 合并插件结果 as ______ } from '../plug.cjs';
+import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件内部类型 as _Task______ } from '../plug.cjs';
 import '@lsby/ts-fp-data';
 
 declare class JSON解析插件<Result extends AnyZodObject> extends __<Result> {
@@ -10,7 +9,6 @@ declare class JSON解析插件<Result extends AnyZodObject> extends __<Result> {
 }
 type 任意JSON解析插件 = JSON解析插件<any>;
 type 任意JSON解析插件项 = _____<任意JSON解析插件>;
-type 合并JSON插件结果<Arr extends Array<_____$1>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____$1> ? 插件项 extends 任意JSON解析插件项 ? z.infer<_Task______<插件项>> & ______<xs> : 合并JSON插件结果<xs> : {} : {} : {};
-type 从接口类型获得JSON参数<接口类型描述> = 合并JSON插件结果<_______<接口类型描述>>;
+type 合并JSON插件结果<Arr extends Array<_____$1>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____$1> ? 插件项 extends 任意JSON解析插件项 ? z.infer<_Task______<插件项>> & 合并JSON插件结果<xs> : 合并JSON插件结果<xs> : {} : {} : {};
 
-export { JSON解析插件, type 从接口类型获得JSON参数, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果 };
+export { JSON解析插件, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果 };