midway-fatcms 0.0.5 → 0.0.7

package/dist/libs/crud-pro/README_FUNC.md

@@ -0,0 +1,193 @@
+# CrudPro 内置函数参考
+
+CrudPro 的 `IFuncCfgModel` 支持 `functionName` 方式调用内置函数。内置函数由四个工具类注册：`DateTimeUtils`、`CompareUtils`、`MixinUtils`、`TypeUtils`。
+
+> 源码位置：`src/libs/crud-pro/services/CrudProServiceBase.ts` → `createBuildInExecuteFuncMap()`
+
+## 调用方式
+
+`functionName` 是 `IFuncCfgModel` 的属性之一，可在 `updateCfg`、`validateCfg`、`executeWhen`、`validate` 等配置中使用。
+
+### 无参调用
+
+```typescript
+'data.created_at': { functionName: 'getCurrentTimeString' }
+```
+
+### 带参调用
+
+```typescript
+'data.order_date': { functionName: 'getCurrentDateFormat', functionParams: ['YYYYMMDD'] }
+```
+
+`functionParams` 中的每个元素可以是基础类型（string / number / boolean），也可以嵌套 `IFuncCfgModel` 对象：
+
+```typescript
+{
+  functionName: 'eq',
+  functionParams: [
+    { contextAsBool: 'res.is_exist' },
+    { constBool: false }
+  ]
+}
+```
+
+## DateTimeUtils — 日期时间
+
+| 函数名 | 参数 | 返回值 | 说明 |
+|--------|------|--------|------|
+| `getCurrentTimeStampMs` | 无 | `number` | 当前时间戳（毫秒） |
+| `getCurrentTimeStampSecond` | 无 | `number` | 当前时间戳（秒） |
+| `getCurrentTimeString` | 无 | `string` | 当前时间，格式 `YYYY-MM-DD HH:mm:ss` |
+| `getCurrentDateFormat` | `format: string` | `string` | 按指定格式返回当前时间 |
+| `getYesterdayDateFormat` | `format: string` | `string` | 按指定格式返回昨天时间 |
+
+**示例：**
+
+```typescript
+updateCfg: {
+  'data.created_at': { functionName: 'getCurrentTimeString' },
+  'data.created_ts': { functionName: 'getCurrentTimeStampMs' },
+  'data.order_date': { functionName: 'getCurrentDateFormat', functionParams: ['YYYYMMDD'] },
+  'data.yesterday': { functionName: 'getYesterdayDateFormat', functionParams: ['YYYY-MM-DD'] },
+}
+```
+
+## CompareUtils — 比较运算
+
+| 函数名 | 参数 | 返回值 | 说明 |
+|--------|------|--------|------|
+| `eq` | `a: any, b: any` | `boolean` | 相等比较（`==`，兼容类型转换） |
+| `ne` | `a: any, b: any` | `boolean` | 不相等 |
+| `gt` | `a: any, b: any` | `boolean` | 大于 |
+| `gte` | `a: any, b: any` | `boolean` | 大于等于 |
+| `lt` | `a: any, b: any` | `boolean` | 小于 |
+| `lte` | `a: any, b: any` | `boolean` | 小于等于 |
+
+**示例：**
+
+```typescript
+// executeWhen：仅当 is_exist 为 false 时执行插入
+executeWhen: {
+  functionName: 'eq',
+  functionParams: [{ contextAsBool: 'res.is_exist' }, { constBool: false }]
+}
+
+// validate：确保数量大于 0
+validate: {
+  functionName: 'gt',
+  functionParams: [{ context: '$current' }, { constNumber: 0 }],
+  message: '数量必须大于0'
+}
+```
+
+## MixinUtils — 通用工具
+
+| 函数名 | 参数 | 返回值 | 说明 |
+|--------|------|--------|------|
+| `isNil` | `obj: any` | `boolean` | 是否为 null 或 undefined |
+| `isNotNil` | `obj: any` | `boolean` | 不为 null 且不为 undefined |
+| `isEmpty` | `obj: any` | `boolean` | 是否为空（null / undefined / 空字符串 / 空数组 / 空对象） |
+| `isNotEmpty` | `obj: any` | `boolean` | 是否非空 |
+| `equals` | `obj1: any, obj2: any` | `boolean` | 严格相等（`===`） |
+| `equalsIgnoreCase` | `str1: string, str2: string` | `boolean` | 忽略大小写比较字符串 |
+| `startsWith` | `str1: string, str2: string` | `boolean` | 字符串前缀判断 |
+| `isValidFieldName` | `s: string` | `boolean` | 合法字段名（字母开头，仅含字母/数字/下划线） |
+| `selectNotEmpty` | `a: any, b: any` | `any` | 返回第一个非空值 |
+| `hasAny` | `a: string[], b: string[]` | `boolean` | 集合 A 是否包含集合 B 中的任意元素 |
+| `parseValueByType` | `value: any, targetType: string` | `any` | 按类型转换值（string / number / boolean / array / JSONObject） |
+| `sleepMs` | `ms: number` | `Promise` | 延时等待 |
+| `uuid` | 无 | `string` | 生成 UUID v4（优先 `crypto.getRandomValues`，降级 `Math.random`） |
+| `generateSnowflakeId` | `machineId?: number` | `string` | 生成雪花ID（64位整数字符串） |
+
+**uuid 和雪花ID 示例：**
+
+```typescript
+updateCfg: {
+  // UUID v4：适合需要标准唯一标识的场景
+  'data.id': { functionName: 'uuid' },
+
+  // 雪花ID：适合需要趋势递增、时间有序的场景
+  'data.order_id': { functionName: 'generateSnowflakeId' },
+
+  // 雪花ID：指定机器ID（0-1023），多实例部署时区分
+  'data.trace_id': { functionName: 'generateSnowflakeId', functionParams: [1] },
+}
+```
+
+> **雪花ID machineId 获取优先级**：函数参数 > 环境变量 `SNOWFLAKE_MACHINE_ID` > `process.pid` 低10位。多实例部署时建议设置环境变量 `SNOWFLAKE_MACHINE_ID` 为 0-1023 的唯一值。
+
+## TypeUtils — 类型判断
+
+| 函数名 | 参数 | 返回值 | 说明 |
+|--------|------|--------|------|
+| `isBasicType` | `value: any` | `boolean` | 基础类型（boolean / string / number / null） |
+| `isBoolean` | `value: any` | `boolean` | 布尔值 |
+| `isString` | `value: any` | `boolean` | 字符串 |
+| `isInteger` | `value: any` | `boolean` | 整数 |
+| `isNumber` | `value: any` | `boolean` | 数字 |
+| `isNumeric` | `value: any` | `boolean` | 数字或可转换数字的字符串 |
+| `isValidName` | `value: any` | `boolean` | 合法命名（字母开头，字母/数字/下划线） |
+| `isChinesePhone` | `value: string` | `boolean` | 中文手机号 |
+| `isEmailStrValid` | `value: string` | `boolean` | 合法邮箱地址 |
+| `pickNumber` | `s: string` | `number \| null` | 从字符串中提取数字部分 |
+
+## 自定义函数扩展
+
+除内置函数外，可通过覆写 `IExecuteContextFunc.getFunctionMap()` 注册自定义函数。
+
+函数查找顺序：`getFunctionMap()` → `buildInExecuteFuncMap`（内置函数），自定义函数优先级更高，可覆盖内置函数。
+
+### 注册方式
+
+继承 `BaseExecuteContextFunc`，覆写 `getFunctionMap()` 方法返回函数映射表：
+
+```typescript
+import { BaseExecuteContextFunc } from './libs/crud-pro/models/ExecuteContextFunc';
+
+class MyContextFunc extends BaseExecuteContextFunc {
+
+  // 覆写此方法，返回自定义函数映射表
+  getFunctionMap(): any {
+    return {
+      // 无参函数
+      generateOrderNo: (prefix: string) => {
+        return prefix + Date.now().toString(36).toUpperCase();
+      },
+
+      // 带参函数：参数来自 functionParams 配置
+      formatAmount: (amount: number, currency: string) => {
+        return currency + ' ' + amount.toFixed(2);
+      },
+
+      // 可访问 FuncContext 的函数（通过 this 关键字）
+      getVisitorName: function(this: any) {
+        return this.reqModel?.visitor?.nickName || 'anonymous';
+      },
+    };
+  }
+}
+
+// 创建 CrudPro 实例时注入
+const crudPro = new CrudPro();
+crudPro.contextFunc = new MyContextFunc(/* 构造参数 */);
+```
+
+### 在配置中使用
+
+注册后即可在 `updateCfg`、`validateCfg`、`functionCfg` 等场景中通过 `functionName` 调用：
+
+```typescript
+const cfgJson: IRequestCfgModel = {
+  method: 'order.create',
+  sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+  updateCfg: {
+    'data.order_no': { functionName: 'generateOrderNo', functionParams: ['PRE'] },
+  },
+};
+```
+
+> **注意**：`functionParams` 中配置的参数会按顺序传入函数。如果函数需要访问 `FuncContext`（如 `reqModel`、`resModel`、`currentValue`），
+> 需使用普通 `function`（非箭头函数）并通过 `this` 访问，框架会以 `func.apply(funcContext, params)` 方式调用。
+
+> **注意**：`generateOrderNo` 等并非内置函数，需通过 `contextFunc` 扩展注册后才可使用，否则运行时抛出 `RUN_FUNCTION_NOT_FOUND` 异常。

package/dist/libs/crud-pro/exceptions.d.ts

@@ -46,6 +46,7 @@ export declare enum Exceptions {
     CFG_UNIQUE_COLUMN_COUNT_MUST_ONE = "CFG_UNIQUE_COLUMN_COUNT_MUST_ONE",
     CFG_ORDER_BY_TYPE_ERROR = "CFG_ORDER_BY_TYPE_ERROR",
     CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID = "CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID",
+    CFG_INVALID_DATA_TYPE = "CFG_INVALID_DATA_TYPE",
     /**
      * 数据传错
      */
@@ -54,6 +55,7 @@ export declare enum Exceptions {
     DATA_GET_DATA_EMPTY_ON_UPDATE = "DATA_GET_DATA_EMPTY_ON_UPDATE",
     DATA_GET_DATA_EMPTY_ON_INSERT_KEYS = "DATA_GET_DATA_EMPTY_ON_INSERT_KEYS",
     DATA_GET_DATA_EMPTY_ON_INSERT_VALUES = "DATA_GET_DATA_EMPTY_ON_INSERT_VALUES",
+    BATCH_INSERT_KEYS_MISMATCH = "BATCH_INSERT_KEYS_MISMATCH",
     /**
      * 请求的Method字段为空
      */

package/dist/libs/crud-pro/exceptions.js

@@ -50,6 +50,7 @@ var Exceptions;
     Exceptions["CFG_UNIQUE_COLUMN_COUNT_MUST_ONE"] = "CFG_UNIQUE_COLUMN_COUNT_MUST_ONE";
     Exceptions["CFG_ORDER_BY_TYPE_ERROR"] = "CFG_ORDER_BY_TYPE_ERROR";
     Exceptions["CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID"] = "CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID";
+    Exceptions["CFG_INVALID_DATA_TYPE"] = "CFG_INVALID_DATA_TYPE";
     /**
      * 数据传错
      */
@@ -58,6 +59,7 @@ var Exceptions;
     Exceptions["DATA_GET_DATA_EMPTY_ON_UPDATE"] = "DATA_GET_DATA_EMPTY_ON_UPDATE";
     Exceptions["DATA_GET_DATA_EMPTY_ON_INSERT_KEYS"] = "DATA_GET_DATA_EMPTY_ON_INSERT_KEYS";
     Exceptions["DATA_GET_DATA_EMPTY_ON_INSERT_VALUES"] = "DATA_GET_DATA_EMPTY_ON_INSERT_VALUES";
+    Exceptions["BATCH_INSERT_KEYS_MISMATCH"] = "BATCH_INSERT_KEYS_MISMATCH";
     /**
      * 请求的Method字段为空
      */

package/dist/libs/crud-pro/interfaces.d.ts

@@ -46,7 +46,7 @@ export interface IRequestModel {
     method?: string;
     columns?: string | string[];
     condition?: Record<string, any>;
-    data?: Record<string, any>;
+    data?: Record<string, any> | Record<string, any>[];
     orderBy?: string | IOrderByItem[];
     limit?: number;
     offset?: number;
@@ -156,6 +156,7 @@ export interface IRequestCfgModel extends IBaseCfgModel {
     transactionIsolation?: number;
     sqlSimpleName?: KeysOfSimpleSQL;
     sqlCfgList?: ISqlCfgModel[];
+    uniqueColumn?: string[];
     updateCfg?: Record<string, IFuncCfgModel>;
     allowCfg?: Record<string, string[]>;
     rejectCfg?: Record<string, string[]>;
@@ -192,4 +193,36 @@ export interface ITableMetaQuery {
     sqlDbType: SqlDbType;
     sqlSchema?: string;
 }
+/**
+ * 表名列表查询参数
+ */
+export interface ITableNamesQuery {
+    sqlDatabase: string;
+    sqlDbType: SqlDbType;
+    sqlSchema?: string;
+}
+/**
+ * 表名查询缓存选项
+ */
+export interface ITableNamesOptions {
+    /** 是否跳过缓存，直接查询数据库 */
+    skipCache?: boolean;
+    /** 查询后是否更新缓存 */
+    refreshCache?: boolean;
+}
+/**
+ * 表信息项（包含表名和类型）
+ */
+export interface ITableInfo {
+    name: string;
+    tableType: string;
+}
+/**
+ * 表信息查询结果
+ */
+export interface ITableListResult {
+    tables: ITableInfo[];
+    tableNames: string[];
+    viewNames: string[];
+}
 export {};

package/dist/libs/crud-pro/models/ExecuteContext.d.ts

@@ -4,7 +4,7 @@ import { SqlCfgModel } from './SqlCfgModel';
 import { Transaction } from './Transaction';
 import { ColumnRelation, ICrudProCfg, ILogger, IVisitor } from '../interfaces';
 import { IExecuteContextFunc } from './ExecuteContextFunc';
-import { ResModelFlexible, ResModelPageQuery } from './ResModel';
+import { ResModelFlexible, ResModelPageQuery, ResModelRowEntity } from './ResModel';
 declare class ExecuteContext {
     private transaction;
     private logger;
@@ -26,8 +26,8 @@ declare class ExecuteContext {
     getReqModel(): RequestModel;
     setReqModel(reqModel: RequestModel): void;
     getResModel(): ResModelFlexible;
-    getOneObj(): any;
-    getResRows(): any[];
+    getOneObj(): ResModelRowEntity;
+    getResRows(): ResModelRowEntity[];
     setResModelItem(resName: string, data: any): void;
     getResModelItem(resName: string): any;
     getResModelForQueryPage(): ResModelPageQuery;

package/dist/libs/crud-pro/models/ExecuteContext.js

@@ -48,9 +48,11 @@ class ExecuteContext {
     getResModel() {
         return this.resModel;
     }
+    // 获取单条数据对象
     getOneObj() {
         return this.resModel['row'];
     }
+    // 获取多条数据对象
     getResRows() {
         return this.resModel['rows'];
     }

package/dist/libs/crud-pro/models/RequestModel.d.ts

@@ -4,18 +4,22 @@ declare class RequestModel {
     method: string;
     columns?: string[];
     condition?: Record<string, any>;
-    data?: Record<string, any>;
+    data?: Record<string, any> | Record<string, any>[];
     limit: number;
     offset: number;
     orderBys?: IOrderByItem[];
     constructor(req: IRequestModel, visitor: IVisitor);
-    private parseOrderBys;
     private parseOffsetList;
     /**
      * 获取对象数据类型
      * @param attrName
      */
     getCondOrDataJsonObject(attrName: string): any;
+    /**
+     * 获取数组类型的数据（用于批量插入）
+     * @param attrName
+     */
+    getCondOrDataAsArray(attrName: string): Record<string, any>[];
     /**
      * 获取基本数据类型
      * @param attrName

package/dist/libs/crud-pro/models/RequestModel.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestModel = void 0;
 const _ = require("lodash");
 const MixinUtils_1 = require("../utils/MixinUtils");
+const OrderByUtils_1 = require("../utils/OrderByUtils");
 const exceptions_1 = require("../exceptions");
 const defaultConfigs_1 = require("../defaultConfigs");
 class RequestModel {
@@ -10,63 +11,11 @@ class RequestModel {
         Object.assign(this, req);
         this.visitor = visitor;
         this.columns = MixinUtils_1.MixinUtils.parseColumns(req.columns);
-        this.orderBys = this.parseOrderBys(req.orderBy);
+        this.orderBys = OrderByUtils_1.OrderByUtils.parseOrderBys(req.orderBy);
         const limitOffset = this.parseOffsetList(req);
         this.limit = limitOffset.limit;
         this.offset = limitOffset.offset;
     }
-    parseOrderBys(orderByStr) {
-        if (MixinUtils_1.MixinUtils.isEmpty(orderByStr)) {
-            return [];
-        }
-        if (Array.isArray(orderByStr)) {
-            return orderByStr
-                .map(obj => {
-                if (typeof obj === 'string') {
-                    return { fieldName: obj, orderType: 'asc' };
-                }
-                const { fieldName, orderType = 'asc' } = obj;
-                if (fieldName) {
-                    return { fieldName, orderType };
-                }
-                return null;
-            })
-                .filter(o => {
-                return !!o;
-            });
-        }
-        const orderByResult = [];
-        const orderByArray = orderByStr
-            .split(',')
-            .map(s => {
-            return s.trim();
-        })
-            .filter(s => !!s);
-        if (MixinUtils_1.MixinUtils.isEmpty(orderByArray)) {
-            return orderByResult;
-        }
-        for (let i = 0; i < orderByArray.length; i++) {
-            const orderByItem = orderByArray[i];
-            let orderType = 'asc'; //默认升序
-            let fieldName = orderByItem;
-            if (orderByItem.endsWith('+')) {
-                // 升序
-                fieldName = orderByItem.substring(0, orderByItem.length - 1);
-                orderType = 'asc'; //升序
-            }
-            else if (orderByItem.endsWith('-')) {
-                //降序
-                fieldName = orderByItem.substring(0, orderByItem.length - 1);
-                orderType = 'desc'; //降序
-            }
-            fieldName = fieldName.trim();
-            if (MixinUtils_1.MixinUtils.isEmpty(fieldName) || !MixinUtils_1.MixinUtils.isValidFieldName(fieldName)) {
-                throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, orderByItem);
-            }
-            orderByResult.push({ fieldName, orderType });
-        }
-        return orderByResult;
-    }
     parseOffsetList(req) {
         const { limit, offset, pageSize, pageNo } = req;
         const limitOffset = {
@@ -102,6 +51,24 @@ class RequestModel {
         }
         throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_GET_COND_OR_DATA_JSONOBJECT, attrName);
     }
+    /**
+     * 获取数组类型的数据（用于批量插入）
+     * @param attrName
+     */
+    getCondOrDataAsArray(attrName) {
+        if (attrName.startsWith('data')) {
+            const dataValue = _.get(this, attrName);
+            if (!dataValue) {
+                return null;
+            }
+            // 如果是数组直接返回
+            if (Array.isArray(dataValue)) {
+                return dataValue;
+            }
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_GET_COND_OR_DATA_JSONOBJECT, attrName);
+        }
+        throw new exceptions_1.CommonException(exceptions_1.Exceptions.RUN_GET_COND_OR_DATA_JSONOBJECT, attrName);
+    }
     /**
      * 获取基本数据类型
      * @param attrName

package/dist/libs/crud-pro/models/ResModel.d.ts

@@ -2,19 +2,21 @@ interface ResModelAffected {
     insertId?: string | number;
     affectedRows: number;
 }
+declare type ResModelRowEntity = Record<string, any>;
 interface ResModelStandard {
-    row?: any;
-    rows?: any[];
+    row?: ResModelRowEntity;
+    rows?: ResModelRowEntity[];
     total_count?: number;
+    is_exist?: boolean;
     affected?: ResModelAffected;
     insert_affected?: ResModelAffected;
     update_affected?: ResModelAffected;
 }
 interface ResModelPageQuery {
-    rows: any[];
+    rows: ResModelRowEntity[];
     total_count: number;
 }
 declare type ResModelFlexible = ResModelStandard & {
     [key: string]: any;
 };
-export { ResModelAffected, ResModelStandard, ResModelFlexible, ResModelPageQuery };
+export { ResModelAffected, ResModelStandard, ResModelFlexible, ResModelPageQuery, ResModelRowEntity };

package/dist/libs/crud-pro/models/ServiceHub.d.ts

@@ -17,4 +17,5 @@ export interface ICurdProServiceHub {
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
     executeFuncCfg(tmpFunCfg: IFuncCfgModel, exeFunCtx: FuncContext): string;
     getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
 }

package/dist/libs/crud-pro/models/keys.d.ts

@@ -51,8 +51,10 @@ export declare enum KeysOfSimpleSQL {
     SIMPLE_QUERY_ONE = "SIMPLE_QUERY_ONE",
     SIMPLE_QUERY_PAGE = "SIMPLE_QUERY_PAGE",
     SIMPLE_QUERY_COUNT = "SIMPLE_QUERY_COUNT",
+    SIMPLE_QUERY_EXIST = "SIMPLE_QUERY_EXIST",
     SIMPLE_UPDATE = "SIMPLE_UPDATE",
     SIMPLE_INSERT = "SIMPLE_INSERT",
+    SIMPLE_BATCH_INSERT = "SIMPLE_BATCH_INSERT",
     SIMPLE_DELETE = "SIMPLE_DELETE",
     SIMPLE_INSERT_ON_DUPLICATE_UPDATE = "SIMPLE_INSERT_ON_DUPLICATE_UPDATE",
     SIMPLE_INSERT_OR_UPDATE = "SIMPLE_INSERT_OR_UPDATE",
@@ -62,7 +64,8 @@ export declare enum KeysOfSqlResPicker {
     UPDATE_RESULT = "UPDATE_RESULT",
     RESULT_FIRST_ROW = "RESULT_FIRST_ROW",
     RESULT_TOTAL_COUNT = "RESULT_TOTAL_COUNT",
-    RESULT_ONE_VALUE = "RESULT_ONE_VALUE"
+    RESULT_ONE_VALUE = "RESULT_ONE_VALUE",
+    RESULT_IS_EXIST = "RESULT_IS_EXIST"
 }
 export declare const KeysOfCustomSQL: {
     SQL_COLUMNS: string;
@@ -73,6 +76,8 @@ export declare const KeysOfCustomSQL: {
     SQL_AS_UPDATE: string;
     SQL_AS_INSERT_KEYS: string;
     SQL_AS_INSERT_VALUES: string;
+    SQL_AS_BATCH_INSERT_KEYS: string;
+    SQL_AS_BATCH_INSERT_VALUES: string;
     SQL_GET_DATA_ATTR_START: string;
     SQL_GET_CONDITION_ATTR_START: string;
     SQL_PICK_RES_AS_NUMBER: string;

package/dist/libs/crud-pro/models/keys.js

@@ -61,8 +61,10 @@ var KeysOfSimpleSQL;
     KeysOfSimpleSQL["SIMPLE_QUERY_ONE"] = "SIMPLE_QUERY_ONE";
     KeysOfSimpleSQL["SIMPLE_QUERY_PAGE"] = "SIMPLE_QUERY_PAGE";
     KeysOfSimpleSQL["SIMPLE_QUERY_COUNT"] = "SIMPLE_QUERY_COUNT";
+    KeysOfSimpleSQL["SIMPLE_QUERY_EXIST"] = "SIMPLE_QUERY_EXIST";
     KeysOfSimpleSQL["SIMPLE_UPDATE"] = "SIMPLE_UPDATE";
     KeysOfSimpleSQL["SIMPLE_INSERT"] = "SIMPLE_INSERT";
+    KeysOfSimpleSQL["SIMPLE_BATCH_INSERT"] = "SIMPLE_BATCH_INSERT";
     KeysOfSimpleSQL["SIMPLE_DELETE"] = "SIMPLE_DELETE";
     KeysOfSimpleSQL["SIMPLE_INSERT_ON_DUPLICATE_UPDATE"] = "SIMPLE_INSERT_ON_DUPLICATE_UPDATE";
     KeysOfSimpleSQL["SIMPLE_INSERT_OR_UPDATE"] = "SIMPLE_INSERT_OR_UPDATE";
@@ -74,6 +76,7 @@ var KeysOfSqlResPicker;
     KeysOfSqlResPicker["RESULT_FIRST_ROW"] = "RESULT_FIRST_ROW";
     KeysOfSqlResPicker["RESULT_TOTAL_COUNT"] = "RESULT_TOTAL_COUNT";
     KeysOfSqlResPicker["RESULT_ONE_VALUE"] = "RESULT_ONE_VALUE";
+    KeysOfSqlResPicker["RESULT_IS_EXIST"] = "RESULT_IS_EXIST";
 })(KeysOfSqlResPicker = exports.KeysOfSqlResPicker || (exports.KeysOfSqlResPicker = {}));
 exports.KeysOfCustomSQL = {
     SQL_COLUMNS: '@@columns',
@@ -84,6 +87,8 @@ exports.KeysOfCustomSQL = {
     SQL_AS_UPDATE: '@@asUpdate:',
     SQL_AS_INSERT_KEYS: '@@asInsertKeys:',
     SQL_AS_INSERT_VALUES: '@@asInsertValues:',
+    SQL_AS_BATCH_INSERT_KEYS: '@@asBatchInsertKeys:',
+    SQL_AS_BATCH_INSERT_VALUES: '@@asBatchInsertValues:',
     // 从Req中取值：单独取Data中的某个字段：获取单个值。
     SQL_GET_DATA_ATTR_START: '@@data',
     SQL_GET_CONDITION_ATTR_START: '@@condition',

package/dist/libs/crud-pro/services/CrudProDataTypeConvertService.d.ts

@@ -0,0 +1,52 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestModel } from '../models/RequestModel';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+/**
+ * 数据类型转换服务
+ * 根据表结构字段类型，在 INSERT/UPDATE 操作前自动转换数据格式，确保数据与数据库方言兼容
+ *
+ * 当前支持的转换：
+ * - PostgreSQL ARRAY 类型：JSON 数组 → PG 数组字面量 {"a","b","c"}
+ */
+declare class CrudProDataTypeConvertService extends CrudProServiceBase {
+    /**
+     * 根据表结构字段类型自动转换 reqModel.data 中的数据格式
+     * 仅对 PostgreSQL 的 INSERT/UPDATE 类型操作生效
+     *
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
+    /**
+     * 遍历数据对象中的 ARRAY 类型字段，将 JSON 数组转为 PG 数组字面量格式
+     */
+    private convertArrayFields;
+    /**
+     * 尝试将值解析为数组
+     * 支持：数组对象、JSON 数组字符串
+     */
+    private tryParseArray;
+    /**
+     * 将 JS 数组转为 PostgreSQL 数组字面量格式
+     *
+     * PG 数组字面量规则：
+     * - 字符串：双引号包裹，内部 " 转义为 \"，\ 转义为 \\   例：{"hello","world"}
+     * - 数字：不加引号                                                    例：{1,2,3}
+     * - 布尔：转为 t/f 不加引号                                           例：{t,f}
+     * - null/undefined：输出 NULL 不加引号                                例：{1,NULL,3}
+     * - 空数组：输出 {}
+     *
+     * @param arr JS 数组
+     * @returns PG 数组字面量字符串
+     */
+    private toPgArrayLiteral;
+    /**
+     * 将单个 JS 值转为 PG 数组元素的字面量表示
+     */
+    private toPgArrayItem;
+    /**
+     * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
+     */
+    private isInsertOrUpdateType;
+}
+export { CrudProDataTypeConvertService };