apaas-oapi-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+import { LoggerLevel } from './logger';
+/**
+ * Client 初始化配置
+ */
+interface ClientOptions {
+    /** 命名空间，例如 app_xxx */
+    namespace: string;
+    /** 应用 clientId */
+    clientId: string;
+    /** 应用 clientSecret */
+    clientSecret: string;
+    /** 是否禁用 token 缓存，每次调用强制刷新 token，默认 false */
+    disableTokenCache?: boolean;
+}
+/**
+ * records_query 接口请求参数
+ */
+interface RecordsQueryParams {
+    /** 对象名称，例如 object_store */
+    object_name: string;
+    /** 请求体数据 */
+    data: any;
+}
+/**
+ * aPaaS OpenAPI 客户端
+ */
+declare class Client {
+    private clientId;
+    private clientSecret;
+    private namespace;
+    private disableTokenCache;
+    private accessToken;
+    private expireTime;
+    private axiosInstance;
+    private loggerLevel;
+    /**
+     * 构造函数
+     * @param options ClientOptions
+     */
+    constructor(options: ClientOptions);
+    /**
+     * 设置日志等级
+     * @param level LoggerLevel
+     */
+    setLoggerLevel(level: LoggerLevel): void;
+    /**
+     * 日志打印方法
+     * @param level LoggerLevel
+     * @param args 打印内容
+     */
+    private log;
+    /**
+     * 初始化 client，自动获取 token
+     */
+    init(): Promise<void>;
+    /**
+     * 获取 accessToken
+     */
+    private getAccessToken;
+    /**
+     * 确保 token 有效，若过期则刷新
+     */
+    private ensureTokenValid;
+    /**
+     * 获取当前 accessToken
+     */
+    get token(): string | null;
+    /**
+     * 获取当前 namespace
+     */
+    get currentNamespace(): string;
+    /**
+     * 对象模块
+     */
+    object: {
+        search: {
+            /**
+             * 单条记录查询
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: (params: {
+                object_name: string;
+                record_id: string;
+                select: string[];
+            }) => Promise<any>;
+            /**
+             * records_query 接口
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            records: (params: RecordsQueryParams) => Promise<any>;
+            /**
+             * 分页查询所有记录
+             * @param params 请求参数
+             * @returns { total, items }
+             */
+            recordsWithIterator: (params: RecordsQueryParams) => Promise<{
+                total: number;
+                items: any[];
+            }>;
+        };
+        update: {
+            /**
+             * 单条更新
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: (params: {
+                object_name: string;
+                record_id: string;
+                record: any;
+            }) => Promise<any>;
+            /**
+             * 批量更新
+             * @param params 请求参数
+             * @returns 所有子请求的返回结果数组
+             */
+            recordsBatchUpdate: (params: {
+                object_name: string;
+                records: any[];
+            }) => Promise<any[]>;
+        };
+        delete: {
+            /**
+             * 单条删除
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: (params: {
+                object_name: string;
+                record_id: string;
+            }) => Promise<any>;
+            /**
+             * 批量删除
+             * @param params 请求参数
+             * @returns 所有子请求的返回结果数组
+             */
+            recordsBatchDelete: (params: {
+                object_name: string;
+                ids: string[];
+            }) => Promise<any[]>;
+        };
+    };
+}
+export declare const apaas: {
+    Client: typeof Client;
+};
+export {};

package/dist/index.js

@@ -0,0 +1,293 @@
+'use strict';
+
+var dayjs = require('dayjs');
+var axios = require('axios');
+
+/**
+ * 日志等级枚举
+ */
+var LoggerLevel;
+(function (LoggerLevel) {
+    LoggerLevel[LoggerLevel["fatal"] = 0] = "fatal";
+    LoggerLevel[LoggerLevel["error"] = 1] = "error";
+    LoggerLevel[LoggerLevel["warn"] = 2] = "warn";
+    LoggerLevel[LoggerLevel["info"] = 3] = "info";
+    LoggerLevel[LoggerLevel["debug"] = 4] = "debug";
+    LoggerLevel[LoggerLevel["trace"] = 5] = "trace";
+})(LoggerLevel || (LoggerLevel = {}));
+
+const { functionLimiter } = require('./limiter');
+/**
+ * aPaaS OpenAPI 客户端
+ */
+class Client {
+    /**
+     * 构造函数
+     * @param options ClientOptions
+     */
+    constructor(options) {
+        this.accessToken = null;
+        this.expireTime = null;
+        this.loggerLevel = LoggerLevel.info;
+        /**
+         * 对象模块
+         */
+        this.object = {
+            search: {
+                /**
+                 * 单条记录查询
+                 * @param params 请求参数
+                 * @returns 接口返回结果
+                 */
+                record: async (params) => {
+                    const { object_name, record_id, select } = params;
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records/${record_id}`;
+                    this.log(LoggerLevel.info, `[单条查询记录] 🔍 开始查询 record_id: ${record_id}`);
+                    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}`);
+                        return response.data;
+                    });
+                    return res;
+                },
+                /**
+                 * records_query 接口
+                 * @param params 请求参数
+                 * @returns 接口返回结果
+                 */
+                records: async (params) => {
+                    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}`);
+                    return res.data;
+                },
+                /**
+                 * 分页查询所有记录
+                 * @param params 请求参数
+                 * @returns { total, items }
+                 */
+                recordsWithIterator: async (params) => {
+                    const { object_name, data } = params;
+                    let results = [];
+                    let nextPageToken = '';
+                    let total = 0;
+                    let page = 0;
+                    do {
+                        await functionLimiter(async () => {
+                            const mergedData = { ...data, page_token: nextPageToken || '' };
+                            const res = await this.object.search.records({
+                                object_name,
+                                data: mergedData
+                            });
+                            page += 1;
+                            if (res.data && Array.isArray(res.data.items)) {
+                                results = results.concat(res.data.items);
+                            }
+                            if (page === 1) {
+                                total = res.data.total || 0;
+                                this.log(LoggerLevel.info, '[批量查询记录] 🔍 接口返回 total:', total);
+                            }
+                            nextPageToken = res.data.next_page_token;
+                            this.log(LoggerLevel.debug, `[批量查询记录] 🔍 第 ${page} 页查询完成，items.length: ${res.data.items.length}`);
+                            return res;
+                        });
+                    } while (nextPageToken);
+                    return { total, items: results };
+                }
+            },
+            update: {
+                /**
+                 * 单条更新
+                 * @param params 请求参数
+                 * @returns 接口返回结果
+                 */
+                record: async (params) => {
+                    const { object_name, record_id, record } = params;
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records/${record_id}`;
+                    this.log(LoggerLevel.info, `[单条更新记录] 💾 开始更新 record_id: ${record_id}`);
+                    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}`);
+                        return response.data;
+                    });
+                    return res;
+                },
+                /**
+                 * 批量更新
+                 * @param params 请求参数
+                 * @returns 所有子请求的返回结果数组
+                 */
+                recordsBatchUpdate: async (params) => {
+                    const { object_name, records } = params;
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_batch`;
+                    const chunkSize = 100;
+                    const chunks = [];
+                    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} 条`);
+                    const results = [];
+                    for (const [index, chunk] of chunks.entries()) {
+                        this.log(LoggerLevel.info, `[批量更新记录] 💾 开始更新第 ${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}`);
+                            return response.data;
+                        });
+                        results.push(res);
+                    }
+                    return results;
+                }
+            },
+            delete: {
+                /**
+                 * 单条删除
+                 * @param params 请求参数
+                 * @returns 接口返回结果
+                 */
+                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}`);
+                    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}`);
+                        return response.data;
+                    });
+                    return res;
+                },
+                /**
+                 * 批量删除
+                 * @param params 请求参数
+                 * @returns 所有子请求的返回结果数组
+                 */
+                recordsBatchDelete: async (params) => {
+                    const { object_name, ids } = params;
+                    const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_batch`;
+                    const chunkSize = 100;
+                    const chunks = [];
+                    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} 条`);
+                    const results = [];
+                    for (const [index, chunk] of chunks.entries()) {
+                        this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 开始删除第 ${index + 1} 组，共 ${chunk.length} 条`);
+                        const res = await functionLimiter(async () => {
+                            await this.ensureTokenValid();
+                            const response = await this.axiosInstance.delete(url, {
+                                headers: { Authorization: `${this.accessToken}` },
+                                data: { ids: chunk }
+                            });
+                            this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 第 ${index + 1} 组删除完成，返回 code: ${response.data.code}`);
+                            return response.data;
+                        });
+                        results.push(res);
+                    }
+                    return results;
+                }
+            }
+        };
+        this.clientId = options.clientId;
+        this.clientSecret = options.clientSecret;
+        this.namespace = options.namespace;
+        this.disableTokenCache = options.disableTokenCache || false;
+        this.axiosInstance = axios.create({
+            baseURL: 'https://ae-openapi.feishu.cn',
+            headers: { 'Content-Type': 'application/json' }
+        });
+        this.log(LoggerLevel.info, 'client initialized');
+    }
+    /**
+     * 设置日志等级
+     * @param level LoggerLevel
+     */
+    setLoggerLevel(level) {
+        this.loggerLevel = level;
+        this.log(LoggerLevel.info, `logger level set to ${LoggerLevel[level]}`);
+    }
+    /**
+     * 日志打印方法
+     * @param level LoggerLevel
+     * @param args 打印内容
+     */
+    log(level, ...args) {
+        if (this.loggerLevel >= level) {
+            const levelStr = LoggerLevel[level];
+            const timestamp = dayjs().format('YYYY-MM-DD HH:mm:ss:SSS');
+            console.log(`[${levelStr}] [${timestamp}]`, ...args);
+        }
+    }
+    /**
+     * 初始化 client，自动获取 token
+     */
+    async init() {
+        await this.ensureTokenValid();
+        this.log(LoggerLevel.info, 'client ready');
+    }
+    /**
+     * 获取 accessToken
+     */
+    async getAccessToken() {
+        const url = '/auth/v1/appToken';
+        const res = await this.axiosInstance.post(url, {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret
+        });
+        if (res.data.code !== '0') {
+            this.log(LoggerLevel.error, `[获取认证] 获取 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');
+    }
+    /**
+     * 确保 token 有效，若过期则刷新
+     */
+    async ensureTokenValid() {
+        if (this.disableTokenCache) {
+            this.log(LoggerLevel.debug, '[获取认证] token cache disabled, refreshing token');
+            await this.getAccessToken();
+            return;
+        }
+        if (!this.accessToken || !this.expireTime) {
+            this.log(LoggerLevel.debug, '[获取认证] 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');
+            await this.getAccessToken();
+        }
+    }
+    /**
+     * 获取当前 accessToken
+     */
+    get token() {
+        return this.accessToken;
+    }
+    /**
+     * 获取当前 namespace
+     */
+    get currentNamespace() {
+        this.log(LoggerLevel.debug, `[获取命名空间] 当前命名空间: ${this.namespace}`);
+        return this.namespace;
+    }
+}
+const apaas = {
+    Client
+};
+
+exports.apaas = apaas;

package/dist/limiter.d.ts

@@ -0,0 +1,17 @@
+import Bottleneck from 'bottleneck';
+/**
+ * 默认 apaas 限流配置
+ */
+export declare const apaasLimiterOptions: {
+    minTime: number;
+    reservoir: number;
+    reservoirRefreshAmount: number;
+    reservoirRefreshInterval: number;
+};
+/**
+ * 创建限流器
+ * @param fn 被限流函数
+ * @param options 自定义限流配置
+ * @returns 包装后的限流函数
+ */
+export declare function functionLimiter<T>(fn: () => Promise<T>, options?: Partial<Bottleneck.ConstructorOptions>): Promise<T>;

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 日志等级枚举
+ */
+export declare enum LoggerLevel {
+    fatal = 0,
+    error = 1,
+    warn = 2,
+    info = 3,
+    debug = 4,
+    trace = 5
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "apaas-oapi-client",
+    "version": "0.1.0",
+    "exports": {
+        "./node-sdk": "./dist/index.js"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "commonjs",
+    "scripts": {
+        "build": "rollup -c",
+        "test": "jest",
+        "dev": "ts-node src/index.ts"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "axios": "^1.10.0",
+        "bottleneck": "^2.19.5",
+        "dayjs": "^1.11.13"
+    },
+    "directories": {
+        "test": "test"
+    },
+    "devDependencies": {
+        "@types/jest": "^30.0.0",
+        "@types/node": "^24.0.7",
+        "jest": "^30.0.3",
+        "rollup": "^4.44.1",
+        "rollup-plugin-typescript2": "^0.36.0",
+        "ts-jest": "^29.4.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.8.3"
+    },
+    "description": ""
+}

package/src/index.ts

@@ -0,0 +1,382 @@
+import dayjs from 'dayjs';
+import axios, { AxiosInstance } from 'axios';
+import { LoggerLevel } from './logger';
+const { functionLimiter } = require('./limiter');
+
+/**
+ * Client 初始化配置
+ */
+interface ClientOptions {
+    /** 命名空间，例如 app_xxx */
+    namespace: string;
+    /** 应用 clientId */
+    clientId: string;
+    /** 应用 clientSecret */
+    clientSecret: string;
+    /** 是否禁用 token 缓存，每次调用强制刷新 token，默认 false */
+    disableTokenCache?: boolean;
+}
+
+/**
+ * 获取 token 接口返回体
+ */
+interface TokenResponse {
+    code: string;
+    data: {
+        accessToken: string;
+        expireTime: number; // 过期时间戳
+    };
+    msg: string;
+}
+
+/**
+ * records_query 接口请求参数
+ */
+interface RecordsQueryParams {
+    /** 对象名称，例如 object_store */
+    object_name: string;
+    /** 请求体数据 */
+    data: any;
+}
+
+/**
+ * aPaaS OpenAPI 客户端
+ */
+class Client {
+    private clientId: string;
+    private clientSecret: string;
+    private namespace: string;
+    private disableTokenCache: boolean;
+    private accessToken: string | null = null;
+    private expireTime: number | null = null;
+    private axiosInstance: AxiosInstance;
+    private loggerLevel: LoggerLevel = LoggerLevel.info;
+
+    /**
+     * 构造函数
+     * @param options ClientOptions
+     */
+    constructor(options: ClientOptions) {
+        this.clientId = options.clientId;
+        this.clientSecret = options.clientSecret;
+        this.namespace = options.namespace;
+        this.disableTokenCache = options.disableTokenCache || false;
+
+        this.axiosInstance = axios.create({
+            baseURL: 'https://ae-openapi.feishu.cn',
+            headers: { 'Content-Type': 'application/json' }
+        });
+        this.log(LoggerLevel.info, 'client initialized');
+    }
+
+    /**
+     * 设置日志等级
+     * @param level LoggerLevel
+     */
+    setLoggerLevel(level: LoggerLevel) {
+        this.loggerLevel = level;
+        this.log(LoggerLevel.info, `logger level set to ${LoggerLevel[level]}`);
+    }
+
+    /**
+     * 日志打印方法
+     * @param level LoggerLevel
+     * @param args 打印内容
+     */
+
+    private log(level: LoggerLevel, ...args: any[]) {
+        if (this.loggerLevel >= level) {
+            const levelStr = LoggerLevel[level];
+            const timestamp = dayjs().format('YYYY-MM-DD HH:mm:ss:SSS');
+            console.log(`[${levelStr}] [${timestamp}]`, ...args);
+        }
+    }
+    /**
+     * 初始化 client，自动获取 token
+     */
+    async init() {
+        await this.ensureTokenValid();
+        this.log(LoggerLevel.info, 'client ready');
+    }
+
+    /**
+     * 获取 accessToken
+     */
+    private async getAccessToken(): Promise<void> {
+        const url = '/auth/v1/appToken';
+        const res = await this.axiosInstance.post<TokenResponse>(url, {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret
+        });
+
+        if (res.data.code !== '0') {
+            this.log(LoggerLevel.error, `[获取认证] 获取 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');
+    }
+
+    /**
+     * 确保 token 有效，若过期则刷新
+     */
+    private async ensureTokenValid() {
+        if (this.disableTokenCache) {
+            this.log(LoggerLevel.debug, '[获取认证] token cache disabled, refreshing token');
+            await this.getAccessToken();
+            return;
+        }
+
+        if (!this.accessToken || !this.expireTime) {
+            this.log(LoggerLevel.debug, '[获取认证] 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');
+            await this.getAccessToken();
+        }
+    }
+
+    /**
+     * 获取当前 accessToken
+     */
+    get token() {
+        return this.accessToken;
+    }
+
+    /**
+     * 获取当前 namespace
+     */
+    get currentNamespace() {
+        this.log(LoggerLevel.debug, `[获取命名空间] 当前命名空间: ${this.namespace}`);
+        return this.namespace;
+    }
+
+    /**
+     * 对象模块
+     */
+    public object = {
+        search: {
+            /**
+             * 单条记录查询
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: async (params: { object_name: string; record_id: string; select: string[] }): Promise<any> => {
+                const { object_name, record_id, select } = params;
+                const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records/${record_id}`;
+
+                this.log(LoggerLevel.info, `[单条查询记录] 🔍 开始查询 record_id: ${record_id}`);
+
+                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}`);
+                    return response.data;
+                });
+
+                return res;
+            },
+
+            /**
+             * records_query 接口
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            records: async (params: RecordsQueryParams): Promise<any> => {
+                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}`);
+                return res.data;
+            },
+
+            /**
+             * 分页查询所有记录
+             * @param params 请求参数
+             * @returns { total, items }
+             */
+            recordsWithIterator: async (params: RecordsQueryParams): Promise<{ total: number; items: any[] }> => {
+                const { object_name, data } = params;
+
+                let results: any[] = [];
+                let nextPageToken: string | undefined = '';
+                let total = 0;
+                let page = 0;
+
+                do {
+                    const pageRes = await functionLimiter(async () => {
+                        const mergedData = { ...data, page_token: nextPageToken || '' };
+
+                        const res = await this.object.search.records({
+                            object_name,
+                            data: mergedData
+                        });
+
+                        page += 1;
+
+                        if (res.data && Array.isArray(res.data.items)) {
+                            results = results.concat(res.data.items);
+                        }
+
+                        if (page === 1) {
+                            total = res.data.total || 0;
+                            this.log(LoggerLevel.info, '[批量查询记录] 🔍 接口返回 total:', total);
+                        }
+
+                        nextPageToken = res.data.next_page_token;
+
+                        this.log(LoggerLevel.debug, `[批量查询记录] 🔍 第 ${page} 页查询完成，items.length: ${res.data.items.length}`);
+                        return res;
+                    });
+                } while (nextPageToken);
+
+                return { total, items: results };
+            }
+        },
+
+        update: {
+            /**
+             * 单条更新
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: async (params: { object_name: string; record_id: string; record: any }): Promise<any> => {
+                const { object_name, record_id, record } = params;
+                const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records/${record_id}`;
+
+                this.log(LoggerLevel.info, `[单条更新记录] 💾 开始更新 record_id: ${record_id}`);
+
+                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}`);
+                    return response.data;
+                });
+
+                return res;
+            },
+
+            /**
+             * 批量更新
+             * @param params 请求参数
+             * @returns 所有子请求的返回结果数组
+             */
+            recordsBatchUpdate: async (params: { object_name: string; records: any[] }): Promise<any[]> => {
+                const { object_name, records } = params;
+                const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_batch`;
+
+                const chunkSize = 100;
+                const chunks: any[][] = [];
+                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} 条`);
+
+                const results: any[] = [];
+                for (const [index, chunk] of chunks.entries()) {
+                    this.log(LoggerLevel.info, `[批量更新记录] 💾 开始更新第 ${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}`);
+                        return response.data;
+                    });
+
+                    results.push(res);
+                }
+
+                return results;
+            }
+        },
+
+        delete: {
+            /**
+             * 单条删除
+             * @param params 请求参数
+             * @returns 接口返回结果
+             */
+            record: async (params: { object_name: string; record_id: string }): Promise<any> => {
+                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}`);
+
+                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}`);
+                    return response.data;
+                });
+
+                return res;
+            },
+
+            /**
+             * 批量删除
+             * @param params 请求参数
+             * @returns 所有子请求的返回结果数组
+             */
+            recordsBatchDelete: async (params: { object_name: string; ids: string[] }): Promise<any[]> => {
+                const { object_name, ids } = params;
+                const url = `/v1/data/namespaces/${this.namespace}/objects/${object_name}/records_batch`;
+
+                const chunkSize = 100;
+                const chunks: string[][] = [];
+                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} 条`);
+
+                const results: any[] = [];
+                for (const [index, chunk] of chunks.entries()) {
+                    this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 开始删除第 ${index + 1} 组，共 ${chunk.length} 条`);
+
+                    const res = await functionLimiter(async () => {
+                        await this.ensureTokenValid();
+
+                        const response = await this.axiosInstance.delete(url, {
+                            headers: { Authorization: `${this.accessToken}` },
+                            data: { ids: chunk }
+                        });
+
+                        this.log(LoggerLevel.info, `[批量删除记录] 🗑️ 第 ${index + 1} 组删除完成，返回 code: ${response.data.code}`);
+                        return response.data;
+                    });
+
+                    results.push(res);
+                }
+
+                return results;
+            }
+        }
+    };
+}
+
+export const apaas = {
+    Client
+};

package/src/limiter.ts

@@ -0,0 +1,29 @@
+import Bottleneck from 'bottleneck';
+
+/**
+ * 默认 apaas 限流配置
+ */
+export const apaasLimiterOptions = {
+    minTime: 200, // 每秒最多发起 5 个数据库操作
+    reservoir: 20, // 最多同时查询 50 个数据库操作
+    reservoirRefreshAmount: 20, // 每次查询完毕后，重置为 50 个数据库操作
+    reservoirRefreshInterval: 1000 // 重置时间间隔为 1 秒
+};
+
+/**
+ * 创建限流器
+ * @param fn 被限流函数
+ * @param options 自定义限流配置
+ * @returns 包装后的限流函数
+ */
+export async function functionLimiter<T>(fn: () => Promise<T>, options: Partial<Bottleneck.ConstructorOptions> = {}): Promise<T> {
+    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();
+}

package/src/logger.ts

@@ -0,0 +1,11 @@
+/**
+ * 日志等级枚举
+ */
+export enum LoggerLevel {
+  fatal = 0,
+  error = 1,
+  warn = 2,
+  info = 3,
+  debug = 4,
+  trace = 5,
+}