apaas-oapi-client 0.1.4 → 0.1.8

package/dist/index.js

@@ -2,7 +2,6 @@
 
 var dayjs = require('dayjs');
 var axios = require('axios');
-var Bottleneck = require('bottleneck');
 
 /**
  * 日志等级枚举
@@ -17,32 +16,7 @@ var LoggerLevel;
     LoggerLevel[LoggerLevel["trace"] = 5] = "trace";
 })(LoggerLevel || (LoggerLevel = {}));
 
-/**
- * 默认 apaas 限流配置
- */
-const apaasLimiterOptions = {
-    minTime: 200, // 每秒最多发起 5 个数据库操作
-    reservoir: 20, // 最多同时查询 50 个数据库操作
-    reservoirRefreshAmount: 20, // 每次查询完毕后，重置为 50 个数据库操作
-    reservoirRefreshInterval: 1000 // 重置时间间隔为 1 秒
-};
-/**
- * 创建限流器
- * @param fn 被限流函数
- * @param options 自定义限流配置
- * @returns 包装后的限流函数
- */
-async function functionLimiter(fn, options = {}) {
-    const limiter = new Bottleneck({
-        minTime: options.minTime || apaasLimiterOptions.minTime,
-        reservoir: options.reservoir || apaasLimiterOptions.reservoir,
-        reservoirRefreshAmount: options.reservoirRefreshAmount || apaasLimiterOptions.reservoirRefreshAmount,
-        reservoirRefreshInterval: options.reservoirRefreshInterval || apaasLimiterOptions.reservoirRefreshInterval
-    });
-    const wrapped = limiter.wrap(fn);
-    return wrapped();
-}
-
+const { functionLimiter } = require('./limiter');
 /**
  * aPaaS OpenAPI 客户端
  */
@@ -59,6 +33,42 @@ class Client {
          * 对象模块
          */
         this.object = {
+            metadata: {
+                /**
+                 * 获取指定对象下指定字段的元数据
+                 * @param params 请求参数 { object_name, field_name }
+                 * @returns 接口返回结果
+                 */
+                field: async (params) => {
+                    const { object_name, field_name } = params;
+                    await this.ensureTokenValid();
+                    const url = `/api/data/v1/namespaces/${this.namespace}/meta/objects/${object_name}/fields/${field_name}`;
+                    this.log(LoggerLevel.debug, `[对象字段查询] 📄 开始获取字段元数据 object_name=${object_name}, field_name=${field_name}`);
+                    const res = await this.axiosInstance.get(url, {
+                        headers: { Authorization: `${this.accessToken}` }
+                    });
+                    this.log(LoggerLevel.debug, `[对象字段查询] 📄 调用完成，返回状态=${res.data.code}`);
+                    this.log(LoggerLevel.trace, `[对象字段查询] 📄 调用完成，返回信息=${JSON.stringify(res.data)}`);
+                    return res.data;
+                },
+                /**
+                 * 获取指定对象的所有字段信息
+                 * @param params 请求参数 { object_name }
+                 * @returns 接口返回结果
+                 */
+                fields: async (params) => {
+                    const { object_name } = params;
+                    await this.ensureTokenValid();
+                    const url = `/api/data/v1/namespaces/${this.namespace}/meta/objects/${object_name}`;
+                    this.log(LoggerLevel.debug, `[对象字段查询] 📄 开始获取对象字段元数据 object_name=${object_name}`);
+                    const res = await this.axiosInstance.get(url, {
+                        headers: { Authorization: `${this.accessToken}` }
+                    });
+                    this.log(LoggerLevel.debug, `[对象字段查询] 📄 调用完成，返回状态=${res.data.code}`);
+                    this.log(LoggerLevel.trace, `[对象字段查询] 📄 调用完成，返回信息=${JSON.stringify(res.data)}`);
+                    return res.data;
+                }
+            },
             search: {
                 /**
                  * 单条记录查询
@@ -72,7 +82,8 @@ class Client {
                     const res = await functionLimiter(async () => {
                         await this.ensureTokenValid();
                         const response = await this.axiosInstance.post(url, { select }, { headers: { Authorization: `${this.accessToken}` } });
-                        this.log(LoggerLevel.info, `[单条查询记录] 🔍 record_id: ${record_id} 查询完成，返回 code: ${response.data.code}`);
+                        this.log(LoggerLevel.debug, `[单条查询记录] 🔍 查询 record_id: ${record_id} 调用完成，返回状态: ${response.data.code}`);
+                        this.log(LoggerLevel.trace, `[单条查询记录] 🔍 查询 record_id: ${record_id} 调用完成，返回信息: ${JSON.stringify(response.data)}`);
                         return response.data;
                     });
                     return res;
@@ -83,13 +94,16 @@ class Client {
                  * @returns 接口返回结果
                  */
                 records: async (params) => {
+                    var _a, _b;
                     const { object_name, data } = params;
                     await this.ensureTokenValid();
                     const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_query`;
                     const res = await this.axiosInstance.post(url, data, {
                         headers: { Authorization: `${this.accessToken}` }
                     });
-                    this.log(LoggerLevel.debug, `[批量查询记录] 🔍 records_query 调用完成，object_name: ${object_name}`);
+                    this.log(LoggerLevel.info, `[批量查询记录] 🔍 接口调用完成`);
+                    this.log(LoggerLevel.debug, `[批量查询记录] 🔍 调用完成，返回状态: ${res.data.code}，返回数据总数${((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.total) || 'unknown'}`);
+                    this.log(LoggerLevel.trace, `[批量查询记录] 🔍 调用完成，返回信息: ${JSON.stringify(res.data)}`);
                     return res.data;
                 },
                 /**
@@ -119,13 +133,92 @@ class Client {
                                 this.log(LoggerLevel.info, '[批量查询记录] 🔍 接口返回 total:', total);
                             }
                             nextPageToken = res.data.next_page_token;
+                            this.log(LoggerLevel.debug, `[批量查询记录] 🔍 第 ${page} 页查询，nextPageToken: ${nextPageToken || ''}`);
                             this.log(LoggerLevel.debug, `[批量查询记录] 🔍 第 ${page} 页查询完成，items.length: ${res.data.items.length}`);
+                            this.log(LoggerLevel.trace, `[批量查询记录] 🔍 第 ${page} 页查询结果: ${JSON.stringify(res.data.items)}`);
                             return res;
                         });
                     } while (nextPageToken);
                     return { total, items: results };
                 }
             },
+            create: {
+                /**
+                 * 单条记录创建
+                 * @param params 请求参数 { object_name, record }
+                 * @returns 接口返回结果
+                 */
+                record: async (params) => {
+                    const { object_name, record } = params;
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records`;
+                    this.log(LoggerLevel.info, `[单条创建记录] ➕ 开始向对象 ${object_name} 创建记录`);
+                    const res = await functionLimiter(async () => {
+                        await this.ensureTokenValid();
+                        const response = await this.axiosInstance.post(url, { record }, {
+                            headers: { Authorization: `${this.accessToken}` }
+                        });
+                        this.log(LoggerLevel.info, `[单条创建记录] ➕ 向对象 ${object_name} 内创建记录，调用完成`);
+                        this.log(LoggerLevel.debug, `[单条创建记录] ➕ 向对象 ${object_name} 内创建数据，调用完成，返回状态: ${response.data.code}`);
+                        this.log(LoggerLevel.trace, `[单条创建记录] ➕ 向对象 ${object_name} 内创建数据，调用完成，返回信息: ${JSON.stringify(response.data)}`);
+                        return response.data;
+                    });
+                    return res;
+                },
+                /**
+                 * 批量创建记录
+                 * @param params 请求参数 { object_name, records }
+                 * @returns 接口返回结果
+                 */
+                records: async (params) => {
+                    const { object_name, records } = params;
+                    await this.ensureTokenValid();
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_batch`;
+                    const res = await this.axiosInstance.post(url, { records }, {
+                        headers: { Authorization: `${this.accessToken}` }
+                    });
+                    this.log(LoggerLevel.info, `[批量创建记录] ➕ 开始向对象 ${object_name} 批量创建记录`);
+                    this.log(LoggerLevel.debug, `[批量创建记录] ➕ 向对象 ${object_name} 批量创建记录，调用完成，返回状态: ${res.data.code}`);
+                    this.log(LoggerLevel.trace, `[批量创建记录] ➕ 向对象 ${object_name} 批量创建记录，调用完成，返回信息: ${JSON.stringify(res.data)}`);
+                    return res.data;
+                },
+                /**
+                 * 分批创建所有记录
+                 * @param params 请求参数 { object_name, records }
+                 * @returns { total, items }
+                 */
+                recordsWithIterator: async (params) => {
+                    const { object_name, records } = params;
+                    let results = [];
+                    let total = records.length;
+                    const chunkSize = 100;
+                    let page = 0;
+                    const chunks = [];
+                    for (let i = 0; i < records.length; i += chunkSize) {
+                        chunks.push(records.slice(i, i + chunkSize));
+                    }
+                    this.log(LoggerLevel.debug, `[批量创建记录] ➕ 总共 ${records.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
+                    this.log(LoggerLevel.trace, `[批量创建记录] ➕ 总共 ${records.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
+                    for (const [index, chunk] of chunks.entries()) {
+                        page += 1;
+                        this.log(LoggerLevel.debug, `[批量创建记录] ➕ 开始创建第 ${index + 1} 组，共 ${chunk.length} 条`);
+                        this.log(LoggerLevel.trace, `[批量创建记录] ➕ 开始创建第 ${index + 1} 组，共 ${chunk.length} 条`);
+                        await functionLimiter(async () => {
+                            const res = await this.object.create.records({
+                                object_name,
+                                records: chunk
+                            });
+                            if (res.data && Array.isArray(res.data.items)) {
+                                results = results.concat(res.data.items);
+                            }
+                            this.log(LoggerLevel.info, `[批量创建记录] ➕ 创建第 ${page} 页数据，调用完成，创建数量: ${res.data.items.length}`);
+                            this.log(LoggerLevel.debug, `[批量创建记录] ➕ 创建第 ${page} 页页数据，调用完成，返回状态: ${res.data.code}`);
+                            this.log(LoggerLevel.trace, `[批量创建记录] ➕ 创建第 ${page} 页页数据，调用结果: ${JSON.stringify(res.data.items)}`);
+                            return res;
+                        });
+                    }
+                    return { total, items: results };
+                }
+            },
             update: {
                 /**
                  * 单条更新
@@ -139,7 +232,9 @@ class Client {
                     const res = await functionLimiter(async () => {
                         await this.ensureTokenValid();
                         const response = await this.axiosInstance.patch(url, { record }, { headers: { Authorization: `${this.accessToken}` } });
-                        this.log(LoggerLevel.info, `[单条更新记录] 💾 record_id: ${record_id} 更新完成，返回 code: ${response.data.code}`);
+                        this.log(LoggerLevel.info, `[单条更新记录] 💾 更新 record_id: ${record_id} 调用完成`);
+                        this.log(LoggerLevel.debug, `[单条更新记录] 💾 更新 record_id: ${record_id} 调用完成，返回状态: ${response.data.code}`);
+                        this.log(LoggerLevel.trace, `[单条更新记录] 💾 更新 record_id: ${record_id} 调用完成，返回信息: ${JSON.stringify(response.data)}`);
                         return response.data;
                     });
                     return res;
@@ -157,14 +252,17 @@ class Client {
                     for (let i = 0; i < records.length; i += chunkSize) {
                         chunks.push(records.slice(i, i + chunkSize));
                     }
-                    this.log(LoggerLevel.info, `[批量更新记录] 💾 总共 ${records.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
+                    this.log(LoggerLevel.debug, `[批量更新记录] 💾 总共 ${records.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
+                    this.log(LoggerLevel.trace, `[批量更新记录] 💾 总共 ${records.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
                     const results = [];
                     for (const [index, chunk] of chunks.entries()) {
-                        this.log(LoggerLevel.info, `[批量更新记录] 💾 开始更新第 ${index + 1} 组，共 ${chunk.length} 条`);
+                        this.log(LoggerLevel.debug, `[批量更新记录] 💾 开始更新第 ${index + 1} 组，共 ${chunk.length} 条`);
+                        this.log(LoggerLevel.trace, `[批量更新记录] 💾 开始更新第 ${index + 1} 组，共 ${chunk.length} 条`);
                         const res = await functionLimiter(async () => {
                             await this.ensureTokenValid();
                             const response = await this.axiosInstance.patch(url, { records: chunk }, { headers: { Authorization: `${this.accessToken}` } });
-                            this.log(LoggerLevel.info, `[批量更新记录] 💾 第 ${index + 1} 组更新完成，返回 code: ${response.data.code}`);
+                            this.log(LoggerLevel.debug, `[批量更新记录] 💾 更新第 ${index + 1} 组调用完成，返回状态: ${JSON.stringify(response.data)}`);
+                            this.log(LoggerLevel.trace, `[批量更新记录] 💾 更新第 ${index + 1} 组调用完成，返回信息: ${response.data}`);
                             return response.data;
                         });
                         results.push(res);
@@ -181,13 +279,13 @@ class Client {
                 record: async (params) => {
                     const { object_name, record_id } = params;
                     const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records/${record_id}`;
-                    this.log(LoggerLevel.info, `[单条删除记录] 🗑️ 开始删除 record_id: ${record_id}`);
+                    this.log(LoggerLevel.trace, `[单条删除记录] 🗑️ 开始删除 record_id: ${record_id}`);
                     const res = await functionLimiter(async () => {
                         await this.ensureTokenValid();
                         const response = await this.axiosInstance.delete(url, {
                             headers: { Authorization: `${this.accessToken}` }
                         });
-                        this.log(LoggerLevel.info, `[单条删除记录] 🗑️ record_id: ${record_id} 删除完成，返回 code: ${response.data.code}`);
+                        this.log(LoggerLevel.info, `[单条删除记录] 🗑️ 删除 record_id: ${record_id} 调用完成，返回信息: ${JSON.stringify(response.data)}`);
                         return response.data;
                     });
                     return res;
@@ -205,7 +303,7 @@ class Client {
                     for (let i = 0; i < ids.length; i += chunkSize) {
                         chunks.push(ids.slice(i, i + chunkSize));
                     }
-                    this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 总共 ${ids.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
+                    this.log(LoggerLevel.debug, `[批量删除记录] 🗑️ 总共 ${ids.length} 条记录，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 条`);
                     const results = [];
                     for (const [index, chunk] of chunks.entries()) {
                         this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 开始删除第 ${index + 1} 组，共 ${chunk.length} 条`);
@@ -215,7 +313,8 @@ class Client {
                                 headers: { Authorization: `${this.accessToken}` },
                                 data: { ids: chunk }
                             });
-                            this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 第 ${index + 1} 组删除完成，返回 code: ${response.data.code}`);
+                            this.log(LoggerLevel.debug, `[批量删除记录] 🗑️ 第 ${index + 1} 组删除完成，返回状态: ${response.data.code}`);
+                            this.log(LoggerLevel.trace, `[批量删除记录] 🗑️ 第 ${index + 1} 组删除完成，返回信息: ${JSON.stringify(response.data)}`);
                             return response.data;
                         });
                         results.push(res);
@@ -224,6 +323,100 @@ class Client {
                 }
             }
         };
+        /**
+         * 部门 ID 交换模块
+         */
+        this.department = {
+            /**
+             * 单个部门 ID 交换
+             * @param params 请求参数
+             * @returns 单个部门映射结果
+             */
+            exchange: async (params) => {
+                const { department_id_type, department_id } = params;
+                // department_id_type 可选值：
+                // - 'department_id' (如 "1758534140403815")
+                // - 'external_department_id' (外部平台 department_id，无固定格式)
+                // - 'external_open_department_id' (以 'oc_' 开头的 open_department_id)
+                const url = '/api/integration/v2/feishu/getDepartments';
+                this.log(LoggerLevel.info, `[部门ID交换] 🔄 开始交换单个部门 ID: ${department_id}`);
+                const res = await functionLimiter(async () => {
+                    await this.ensureTokenValid();
+                    const response = await this.axiosInstance.post(url, {
+                        department_id_type,
+                        department_ids: [department_id]
+                    }, {
+                        headers: { Authorization: `${this.accessToken}` }
+                    });
+                    this.log(LoggerLevel.debug, `[部门ID交换] 🔄 交换部门 ID: ${department_id} 调用完成，返回状态: ${response.data.code}`);
+                    this.log(LoggerLevel.debug, `[部门ID交换] 🔄 交换部门 ID: ${department_id} 调用完成，返回信息: ${JSON.stringify(response.data)}`);
+                    return response.data.data[0]; // 返回第一个元素
+                });
+                return res;
+            },
+            /**
+             * 批量部门 ID 交换
+             * @param params 请求参数
+             * @returns 所有子请求的返回结果数组
+             */
+            batchExchange: async (params) => {
+                const { department_id_type, department_ids } = params;
+                // department_id_type 可选值：
+                // - 'department_id' (如 "1758534140403815")
+                // - 'external_department_id' (外部平台 department_id，无固定格式)
+                // - 'external_open_department_id' (以 'oc_' 开头的 open_department_id)
+                const url = '/api/integration/v2/feishu/getDepartments';
+                const chunkSize = 100;
+                const chunks = [];
+                for (let i = 0; i < department_ids.length; i += chunkSize) {
+                    chunks.push(department_ids.slice(i, i + chunkSize));
+                }
+                this.log(LoggerLevel.info, `[批量部门ID交换] 🔄 总共 ${department_ids.length} 个部门 ID，拆分为 ${chunks.length} 组，每组最多 ${chunkSize} 个`);
+                const results = [];
+                for (const [index, chunk] of chunks.entries()) {
+                    this.log(LoggerLevel.info, `[批量部门ID交换] 🔄 开始交换第 ${index + 1} 组，共 ${chunk.length} 个`);
+                    const res = await functionLimiter(async () => {
+                        await this.ensureTokenValid();
+                        const response = await this.axiosInstance.post(url, {
+                            department_id_type,
+                            department_ids: chunk
+                        }, {
+                            headers: { Authorization: `${this.accessToken}` }
+                        });
+                        this.log(LoggerLevel.debug, `[批量部门ID交换] 🔄 交换第 ${index + 1} 组调用完成，返回状态: ${response.data.code}`);
+                        this.log(LoggerLevel.trace, `[批量部门ID交换] 🔄 交换第 ${index + 1} 组调用完成，返回信息: ${JSON.stringify(response.data)}`);
+                        return response.data.data;
+                    });
+                    results.push(...res);
+                }
+                return results;
+            }
+        };
+        /**
+         * 云函数模块
+         */
+        this.function = {
+            /**
+             * 调用云函数
+             * @param params 请求参数 { name: string; params: any }
+             * @returns 接口返回结果
+             */
+            invoke: async (params) => {
+                const { name, params: functionParams } = params;
+                await this.ensureTokenValid();
+                const url = `/api/cloudfunction/v1/namespaces/${this.namespace}/invoke/${name}`;
+                this.log(LoggerLevel.info, `[调用云函数] ☁️ 云函数 ${name} 开始调用`);
+                const res = await this.axiosInstance.post(url, { params: functionParams }, {
+                    headers: {
+                        Authorization: `${this.accessToken}`,
+                        'Content-Type': 'application/json'
+                    }
+                });
+                this.log(LoggerLevel.debug, `[调用云函数] ☁️ 云函数 ${name} 调用完成，返回状态: code=${res.data.code}`);
+                this.log(LoggerLevel.trace, `[调用云函数] ☁️ 云函数 ${name} 调用完成，返回信息: code=${JSON.stringify(res.data)}`);
+                return res.data;
+            }
+        };
         this.clientId = options.clientId;
         this.clientSecret = options.clientSecret;
         this.namespace = options.namespace;
@@ -232,7 +425,7 @@ class Client {
             baseURL: 'https://ae-openapi.feishu.cn',
             headers: { 'Content-Type': 'application/json' }
         });
-        this.log(LoggerLevel.info, 'client initialized');
+        this.log(LoggerLevel.info, '[client] initialized');
     }
     /**
      * 设置日志等级
@@ -240,7 +433,7 @@ class Client {
      */
     setLoggerLevel(level) {
         this.loggerLevel = level;
-        this.log(LoggerLevel.info, `logger level set to ${LoggerLevel[level]}`);
+        this.log(LoggerLevel.info, `[logger] logger level set to ${LoggerLevel[level]}`);
     }
     /**
      * 日志打印方法
@@ -259,7 +452,7 @@ class Client {
      */
     async init() {
         await this.ensureTokenValid();
-        this.log(LoggerLevel.info, 'client ready');
+        this.log(LoggerLevel.info, '[client] ready');
     }
     /**
      * 获取 accessToken
@@ -271,30 +464,30 @@ class Client {
             clientSecret: this.clientSecret
         });
         if (res.data.code !== '0') {
-            this.log(LoggerLevel.error, `[获取认证] 获取 accessToken 失败: ${res.data.msg}`);
+            this.log(LoggerLevel.error, `[fetch token] 获取 accessToken 失败: ${res.data.msg}`);
             throw new Error(`获取 accessToken 失败: ${res.data.msg}`);
         }
         this.accessToken = res.data.data.accessToken;
         this.expireTime = res.data.data.expireTime;
-        this.log(LoggerLevel.info, '[获取认证] accessToken refreshed');
+        this.log(LoggerLevel.info, '[client] token refreshed');
     }
     /**
      * 确保 token 有效，若过期则刷新
      */
     async ensureTokenValid() {
         if (this.disableTokenCache) {
-            this.log(LoggerLevel.debug, '[获取认证] token cache disabled, refreshing token');
+            this.log(LoggerLevel.debug, '[client] token cache disabled, refreshing token');
             await this.getAccessToken();
             return;
         }
         if (!this.accessToken || !this.expireTime) {
-            this.log(LoggerLevel.debug, '[获取认证] no token cached, fetching new token');
+            this.log(LoggerLevel.debug, '[client] no token cached, fetching new token');
             await this.getAccessToken();
             return;
         }
         const now = dayjs().valueOf();
         if (now + 60 * 1000 > this.expireTime) {
-            this.log(LoggerLevel.debug, '[获取认证] token expired, refreshing');
+            this.log(LoggerLevel.debug, '[client] token expired, refreshing');
             await this.getAccessToken();
         }
     }
@@ -308,7 +501,7 @@ class Client {
      * 获取当前 namespace
      */
     get currentNamespace() {
-        this.log(LoggerLevel.debug, `[获取命名空间] 当前命名空间: ${this.namespace}`);
+        this.log(LoggerLevel.debug, `🏷️ [获取命名空间] 当前命名空间: ${this.namespace}`);
         return this.namespace;
     }
 }

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "apaas-oapi-client",
-    "version": "0.1.4",
+    "version": "0.1.8",
+    "main": "dist/index.js",
     "exports": {
-        "./node-sdk": "./dist/index.js",
-        ".": "./dist/index.js"
+        ".": "./dist/index.js",
+        "./node-sdk": "./dist/index.js"
     },
-    "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "commonjs",
     "scripts": {