mobx-lark 2.8.0 → 2.8.1

package/dist/module/BITable/index.d.ts

@@ -15,85 +15,91 @@ export interface BiDataQueryOptions {
 /**
  * @see {@link https://open.feishu.cn/document/ukTMukTMukTM/uUDN04SN0QjL1QDN/bitable-overview}
  */
-export declare function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T>>(Base?: typeof ListModel): abstract new (appId: string, tableId: string) => {
-    requiredKeys: readonly (keyof T)[];
-    sort: Partial<Record<keyof T, "ASC" | "DESC">>;
+export declare function BiDataTable<D extends DataObject, F extends Filter<D> = Filter<D>>(Base?: typeof ListModel): abstract new (appId: string, tableId: string) => {
+    requiredKeys: readonly (keyof D)[];
+    sort: Partial<Record<keyof D, "ASC" | "DESC">>;
     queryOptions: BiDataQueryOptions;
     currentViewId?: string;
-    extractFields({ fields, ...meta }: TableRecord<T>): T;
+    keyMap?: Partial<Record<keyof D, string>>;
+    readonly nameMap: any;
+    extractFields({ fields, ...meta }: TableRecord<D>): D;
     /**
      * @deprecated
      */
-    normalize: ({ fields, ...meta }: TableRecord<T>) => T;
-    wrapFields(fields: F): T;
+    normalize: ({ fields, ...meta }: TableRecord<D>) => D;
+    /**
+     * @protected
+     */
+    mapFields({ fields, ...meta }: TableRecord<DataObject>): D;
+    wrapFields(fields: F): D;
     /**
      * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/get}
      */
-    getOne(id: string): Promise<T>;
+    getOne(id: string): Promise<D>;
     /**
      * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/create}
      * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/update}
      */
-    updateOne(data: F, id?: string): Promise<T>;
+    updateOne(data: F, id?: string): Promise<D>;
+    mapFilter(filter: DataObject): F;
     makeFilter(filter: F): string;
     /**
      * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/list}
      */
-    openStream(filter: F): AsyncGenerator<T, void, unknown>;
-    getViewList(viewId: string, pageIndex?: number, pageSize?: number): Promise<T[]>;
-    getViewAll(viewId: string, pageSize?: number): Promise<T[]>;
-    stream?: AsyncGenerator<T, void, any> | undefined;
+    openStream(filter: F): AsyncGenerator<D, void, unknown>;
+    getViewList(viewId: string, pageIndex?: number, pageSize?: number): Promise<D[]>;
+    getViewAll(viewId: string, pageSize?: number): Promise<D[]>;
+    stream?: AsyncGenerator<D, void, any> | undefined;
     clearList: (() => void) & (() => void);
     clear: (() => void) & (() => void);
-    restoreList: (({ filter, pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<T, Partial<import("mobx-restful").NewData<T>>>, "filter" | "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => Promise<void>) & (({ pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<T, Partial<import("mobx-restful").NewData<T>>>, "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => void);
-    loadStream(filter: F, newCount: number): Promise<T[]>;
+    restoreList: (({ filter, pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<D, Partial<import("mobx-restful").NewData<D>>>, "filter" | "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => Promise<void>) & (({ pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<D, Partial<import("mobx-restful").NewData<D>>>, "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => void);
+    loadStream(filter: F, newCount: number): Promise<D[]>;
     loadPage: ((pageIndex: number, pageSize: number, filter: F) => Promise<{
-        pageData: T[];
+        pageData: D[];
         totalCount: number;
-    }>) & ((pageIndex: number, pageSize: number, filter: F) => Promise<PageData<T>>);
+    }>) & ((pageIndex: number, pageSize: number, filter: F) => Promise<PageData<D>>);
     pageIndex: number;
     pageSize: number;
     filter: F;
     totalCount: number;
-    pageList: T[][];
-    readonly currentPage: T[];
+    pageList: D[][];
+    readonly currentPage: D[];
     readonly pageCount: number;
-    readonly allItems: T[];
+    readonly allItems: D[];
     readonly noMore: boolean;
-    statistic: Partial<Record<import("web-utility").TypeKeys<T, import("web-utility").IndexKey>, Record<string, number>>>;
-    turnTo: ((pageIndex: number, pageSize?: number) => ListModel<T, F>) & ((pageIndex: number, pageSize?: number) => ListModel<T, F>);
+    statistic: Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>;
+    turnTo: ((pageIndex: number, pageSize?: number) => ListModel<D, F>) & ((pageIndex: number, pageSize?: number) => ListModel<D, F>);
     loadNewPage: ((pageIndex: number, pageSize: number, filter: F) => Promise<{
-        pageData: T[];
+        pageData: D[];
         totalCount: number;
     }>) & ((pageIndex: number, pageSize: number, filter: F) => Promise<{
-        pageData: T[];
+        pageData: D[];
         totalCount: number;
     }>);
-    getList: ((filter?: F | undefined, pageIndex?: number, pageSize?: number) => Promise<T[]>) & ((filter?: F | undefined, pageIndex?: number, pageSize?: number) => Promise<T[]>);
-    refreshList: (() => Promise<T[]>) & (() => Promise<T[]>);
-    getAllInStream: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<T, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<T, void, unknown>);
-    getAll: ((filter?: F | undefined, pageSize?: number) => Promise<T[]>) & ((filter?: F | undefined, pageSize?: number) => Promise<T[]>);
-    countAll: ((keys: import("web-utility").TypeKeys<T, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<T, import("web-utility").IndexKey>, Record<string, number>>>>) & ((keys: import("web-utility").TypeKeys<T, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<T, import("web-utility").IndexKey>, Record<string, number>>>>);
+    getList: ((filter?: F | undefined, pageIndex?: number, pageSize?: number) => Promise<D[]>) & ((filter?: F | undefined, pageIndex?: number, pageSize?: number) => Promise<D[]>);
+    refreshList: (() => Promise<D[]>) & (() => Promise<D[]>);
+    getAllInStream: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>);
+    getAll: ((filter?: F | undefined, pageSize?: number) => Promise<D[]>) & ((filter?: F | undefined, pageSize?: number) => Promise<D[]>);
+    countAll: ((keys: import("web-utility").TypeKeys<D, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>>) & ((keys: import("web-utility").TypeKeys<D, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>>);
     indexOf: ((id: import("mobx-restful").IDType) => number) & ((id: import("mobx-restful").IDType) => number);
-    changeOne: ((data: Partial<T>, id: import("mobx-restful").IDType, patch?: boolean) => void) & ((data: Partial<T>, id: import("mobx-restful").IDType, patch?: boolean) => void);
+    changeOne: ((data: Partial<D>, id: import("mobx-restful").IDType, patch?: boolean) => void) & ((data: Partial<D>, id: import("mobx-restful").IDType, patch?: boolean) => void);
     removeOne: ((id: import("mobx-restful").IDType) => Promise<void>) & ((id: import("mobx-restful").IDType) => Promise<void>);
     deleteOne: ((id: import("mobx-restful").IDType) => Promise<void>) & ((id: import("mobx-restful").IDType) => Promise<void>);
     client: import("mobx-restful/dist/utility").RESTClient;
     baseURI: string;
-    indexKey: keyof T;
-    currentOne: T;
+    indexKey: keyof D;
+    currentOne: D;
     clearCurrent: (() => void) & (() => void);
     downloading: number;
     uploading: number;
-    [Symbol.asyncIterator]: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<T, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<T, void, unknown>);
+    [Symbol.asyncIterator]: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>);
 };
 export type BiSearchFilter<D extends DataObject> = Filter<D> & {
     keywords?: string;
 };
-export declare function BiSearch<D extends DataObject, F extends BiSearchFilter<D> = BiSearchFilter<D>>(Model: Constructor<ListModel<D, F>>): abstract new (...args: any[]) => {
+export declare function BiSearch<D extends DataObject, F extends BiSearchFilter<D> = BiSearchFilter<D>>(Model: ReturnType<typeof BiDataTable<D, F>>): abstract new (appId: string, tableId: string) => {
     baseURI: string;
     client: RESTClient;
-    loadPage: (pageIndex: number, pageSize: number, filter: F) => Promise<PageData<D>>;
     searchKeys: readonly (keyof TableRecordFields)[];
     keywords: string;
     makeFilter(filter: F): string;
@@ -102,40 +108,79 @@ export declare function BiSearch<D extends DataObject, F extends BiSearchFilter<
      * @deprecated since v2.4.2, use {@link getList} instead
      */
     getSearchList(keywords: string, pageIndex?: number, pageSize?: number): Promise<D[]>;
+    requiredKeys: readonly (keyof D)[];
+    sort: Partial<Record<keyof D, "ASC" | "DESC">>;
+    queryOptions: BiDataQueryOptions;
+    currentViewId?: string;
+    keyMap?: Partial<Record<keyof D, string>> | undefined;
+    readonly nameMap: any;
+    extractFields({ fields, ...meta }: TableRecord<D>): D;
+    /**
+     * @deprecated
+     */
+    normalize: ({ fields, ...meta }: TableRecord<D>) => D;
+    /**
+     * @protected
+     */
+    mapFields({ fields, ...meta }: TableRecord<DataObject>): D;
+    wrapFields(fields: F): D;
+    /**
+     * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/get}
+     */
+    getOne(id: string): Promise<D>;
+    /**
+     * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/create}
+     * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/update}
+     */
+    updateOne(data: F, id?: string): Promise<D>;
+    mapFilter(filter: DataObject): F;
+    /**
+     * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/list}
+     */
+    openStream(filter: F): AsyncGenerator<D, void, unknown>;
+    getViewList(viewId: string, pageIndex?: number, pageSize?: number): Promise<D[]>;
+    getViewAll(viewId: string, pageSize?: number): Promise<D[]>;
+    stream?: AsyncGenerator<D, void, any> | undefined;
+    clearList: (() => void) & (() => void);
+    clear: (() => void) & (() => void);
+    restoreList: (({ filter, pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<D, Partial<import("mobx-restful").NewData<D>>>, "filter" | "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => Promise<void>) & (({ pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<D, Partial<import("mobx-restful").NewData<D>>>, "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined) => void);
+    loadStream(filter: F, newCount: number): Promise<D[]>;
+    loadPage: ((pageIndex: number, pageSize: number, filter: F) => Promise<{
+        pageData: D[];
+        totalCount: number;
+    }>) & ((pageIndex: number, pageSize: number, filter: F) => Promise<PageData<D>>);
     pageIndex: number;
     pageSize: number;
     filter: F;
-    totalCount: number | undefined;
+    totalCount: number;
     pageList: D[][];
     readonly currentPage: D[];
     readonly pageCount: number;
     readonly allItems: D[];
     readonly noMore: boolean;
     statistic: Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>;
-    clearList(): void;
-    clear(): void;
-    restoreList({ pageIndex, pageSize, allItems, totalCount }?: Partial<Pick<ListModel<D, Partial<import("mobx-restful").NewData<D>>>, "pageIndex" | "pageSize" | "allItems" | "totalCount">> | undefined): void;
-    turnTo(pageIndex: number, pageSize?: number): ListModel<D, F>;
-    loadNewPage(pageIndex: number, pageSize: number, filter: F): Promise<{
+    turnTo: ((pageIndex: number, pageSize?: number) => ListModel<D, F>) & ((pageIndex: number, pageSize?: number) => ListModel<D, F>);
+    loadNewPage: ((pageIndex: number, pageSize: number, filter: F) => Promise<{
+        pageData: D[];
+        totalCount: number;
+    }>) & ((pageIndex: number, pageSize: number, filter: F) => Promise<{
         pageData: D[];
         totalCount: number;
-    }>;
-    refreshList(): Promise<D[]>;
-    getAllInStream(filter?: F | undefined, pageSize?: number): AsyncGenerator<D, void, unknown>;
-    getAll(filter?: F | undefined, pageSize?: number): Promise<D[]>;
-    countAll(keys: import("web-utility").TypeKeys<D, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number): Promise<Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>>;
-    indexOf(id: import("mobx-restful").IDType): number;
-    changeOne(data: Partial<D>, id: import("mobx-restful").IDType, patch?: boolean): void;
-    updateOne(data: Partial<import("mobx-restful").NewData<D>>, id?: import("mobx-restful").IDType): Promise<D>;
-    removeOne(id: import("mobx-restful").IDType): Promise<void>;
-    deleteOne(id: import("mobx-restful").IDType): Promise<void>;
-    [Symbol.asyncIterator]: (filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>;
+    }>);
+    refreshList: (() => Promise<D[]>) & (() => Promise<D[]>);
+    getAllInStream: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>);
+    getAll: ((filter?: F | undefined, pageSize?: number) => Promise<D[]>) & ((filter?: F | undefined, pageSize?: number) => Promise<D[]>);
+    countAll: ((keys: import("web-utility").TypeKeys<D, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>>) & ((keys: import("web-utility").TypeKeys<D, import("web-utility").IndexKey>[], filter?: F | undefined, pageSize?: number) => Promise<Partial<Record<import("web-utility").TypeKeys<D, import("web-utility").IndexKey>, Record<string, number>>>>);
+    indexOf: ((id: import("mobx-restful").IDType) => number) & ((id: import("mobx-restful").IDType) => number);
+    changeOne: ((data: Partial<D>, id: import("mobx-restful").IDType, patch?: boolean) => void) & ((data: Partial<D>, id: import("mobx-restful").IDType, patch?: boolean) => void);
+    removeOne: ((id: import("mobx-restful").IDType) => Promise<void>) & ((id: import("mobx-restful").IDType) => Promise<void>);
+    deleteOne: ((id: import("mobx-restful").IDType) => Promise<void>) & ((id: import("mobx-restful").IDType) => Promise<void>);
     indexKey: keyof D;
     currentOne: D;
-    clearCurrent(): void;
-    getOne(id: import("mobx-restful").IDType): Promise<D>;
+    clearCurrent: (() => void) & (() => void);
     downloading: number;
     uploading: number;
+    [Symbol.asyncIterator]: ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>) & ((filter?: F | undefined, pageSize?: number) => AsyncGenerator<D, void, unknown>);
 };
 interface BiSearchModel extends InstanceType<ReturnType<typeof BiSearch<TableRecordFields, any>>> {
 }
@@ -202,11 +247,17 @@ export declare function BiTable(): abstract new (id: string) => {
         sort: Partial<Record<keyof T, "ASC" | "DESC">>;
         queryOptions: BiDataQueryOptions;
         currentViewId?: string;
+        keyMap?: Partial<Record<keyof T, string>> | undefined;
+        readonly nameMap: any;
         extractFields({ fields, ...meta }: TableRecord<T>): T;
         /**
          * @deprecated
          */
         normalize: ({ fields, ...meta }: TableRecord<T>) => T;
+        /**
+         * @protected
+         */
+        mapFields({ fields, ...meta }: TableRecord<DataObject>): T;
         wrapFields(fields: F): T;
         /**
          * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/get}
@@ -217,6 +268,7 @@ export declare function BiTable(): abstract new (id: string) => {
          * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/update}
          */
         updateOne(data: F, id?: string): Promise<T>;
+        mapFilter(filter: DataObject): F;
         makeFilter(filter: F): string;
         /**
          * @see {@link https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/list}

package/dist/module/BITable/utility.d.ts

@@ -1,5 +1,6 @@
 import { DataObject } from 'mobx-restful';
 import { TableCellLink, TableCellLocation, TableCellRelation, TableCellText } from './type';
+export declare const mapKeys: <I extends DataObject, O extends DataObject>(data: I, map: Partial<Record<keyof I, PropertyKey>>) => O;
 export type FilterOperator = '<' | '<=' | '=' | '!=' | '=>' | '>' | 'contains';
 /**
  * @see https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/filter

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx-lark",
-    "version": "2.8.0",
+    "version": "2.8.1",
     "license": "LGPL-3.0",
     "author": "shiy2008@gmail.com",
     "description": "Unofficial TypeScript SDK for FeiShu/Lark API, which is based on MobX-RESTful.",
@@ -25,14 +25,14 @@
         "url": "https://github.com/idea2app/MobX-Lark/issues"
     },
     "dependencies": {
-        "@swc/helpers": "^0.5.20",
+        "@swc/helpers": "^0.5.21",
         "@types/react": "^19.2.14",
         "koajax": "^3.3.0",
         "lodash.memoize": "^4.1.2",
         "mobx": "^6.15.0",
         "mobx-restful": "^2.1.4",
         "regenerator-runtime": "^0.14.1",
-        "web-utility": "^4.6.4"
+        "web-utility": "^4.6.5"
     },
     "peerDependencies": {
         "react": ">=16"
@@ -42,10 +42,10 @@
         "@parcel/transformer-typescript-tsc": "~2.16.4",
         "@types/fs-extra": "^11.0.4",
         "@types/lodash.memoize": "^4.1.9",
-        "@types/node": "^24.12.0",
+        "@types/node": "^24.12.2",
         "@types/react-dom": "^19.2.3",
         "@types/turndown": "^5.0.6",
-        "dotenv": "^17.3.1",
+        "dotenv": "^17.4.0",
         "fs-extra": "^11.3.4",
         "husky": "^9.1.7",
         "lint-staged": "^16.4.0",
@@ -54,7 +54,7 @@
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ts-node": "^10.9.2",
-        "turndown": "^7.2.2",
+        "turndown": "^7.2.4",
         "typedoc": "^0.28.18",
         "typedoc-plugin-mdn-links": "^5.1.1",
         "typescript": "~5.8.3"

package/src/module/BITable/index.ts

@@ -13,7 +13,7 @@ import {
     TableRecordFields,
     TableView
 } from './type';
-import { makeSimpleFilter } from './utility';
+import { makeSimpleFilter, mapKeys } from './utility';
 
 export * from './type';
 export * from './utility';
@@ -31,13 +31,13 @@ export interface BiDataQueryOptions {
 /**
  * @see {@link https://open.feishu.cn/document/ukTMukTMukTM/uUDN04SN0QjL1QDN/bitable-overview}
  */
-export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T>>(
+export function BiDataTable<D extends DataObject, F extends Filter<D> = Filter<D>>(
     Base = ListModel
 ) {
-    abstract class BiDataTableModel extends Stream<T, F>(Base) {
-        requiredKeys: readonly (keyof T)[] = [];
+    abstract class BiDataTableModel extends Stream<D, F>(Base) {
+        requiredKeys: readonly (keyof D)[] = [];
 
-        sort: Partial<Record<keyof T, 'ASC' | 'DESC'>> = {};
+        sort: Partial<Record<keyof D, 'ASC' | 'DESC'>> = {};
 
         queryOptions: BiDataQueryOptions = {
             text_field_as_array: true,
@@ -50,7 +50,15 @@ export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T
             this.baseURI = `bitable/v1/apps/${appId}/tables/${tableId}/records`;
         }
 
-        extractFields({ fields, ...meta }: TableRecord<T>): T {
+        keyMap?: Partial<Record<keyof D, string>>;
+
+        get nameMap() {
+            return this.keyMap
+                ? Object.fromEntries(Object.entries(this.keyMap).map(([key, name]) => [name, key]))
+                : {};
+        }
+
+        extractFields({ fields, ...meta }: TableRecord<D>): D {
             return { ...meta, ...fields };
         }
 
@@ -59,8 +67,19 @@ export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T
          */
         normalize = this.extractFields;
 
+        /**
+         * @protected
+         */
+        mapFields({ fields, ...meta }: TableRecord<DataObject>) {
+            const { nameMap } = this;
+
+            const mappedData = isEmpty(nameMap) ? (fields as D) : (mapKeys(fields, nameMap) as D);
+
+            return this.normalize({ fields: mappedData, ...meta });
+        }
+
         wrapFields(fields: F) {
-            return fields as unknown as T;
+            return fields as unknown as D;
         }
 
         /**
@@ -68,10 +87,10 @@ export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T
          */
         @toggle('downloading')
         async getOne(id: string) {
-            const { body } = await this.client.get<TableRecordData<T>>(
+            const { body } = await this.client.get<TableRecordData<D>>(
                 `${this.baseURI}/${id}?${buildURLData(this.queryOptions)}`
             );
-            return (this.currentOne = this.normalize(body!.data!.record));
+            return (this.currentOne = this.mapFields(body!.data!.record));
         }
 
         /**
@@ -80,29 +99,31 @@ export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T
          */
         @toggle('uploading')
         async updateOne(data: F, id?: string) {
-            const fields = this.wrapFields(data);
+            const rawData = this.wrapFields(data);
+
+            const fields = isEmpty(this.keyMap) ? rawData : (mapKeys(rawData, this.keyMap) as D);
 
             const { body } = await (id
-                ? this.client.put<TableRecordData<T>>(`${this.baseURI}/${id}`, {
-                      fields
-                  })
-                : this.client.post<TableRecordData<T>>(this.baseURI, {
-                      fields
-                  }));
-            return (this.currentOne = this.normalize(body!.data!.record));
+                ? this.client.put<TableRecordData<D>>(`${this.baseURI}/${id}`, { fields })
+                : this.client.post<TableRecordData<D>>(this.baseURI, { fields }));
+
+            return (this.currentOne = this.mapFields(body!.data!.record));
+        }
+
+        mapFilter(filter: DataObject) {
+            return isEmpty(this.keyMap) ? (filter as F) : (mapKeys(filter, this.keyMap) as F);
         }
 
         makeFilter(filter: F) {
-            return [
+            const requiredFilter =
                 this.requiredKeys[0] &&
-                    makeSimpleFilter(
-                        Object.fromEntries(this.requiredKeys.map(key => [key, ''])),
-                        '!='
-                    ),
-                !isEmpty(filter) && makeSimpleFilter(filter)
-            ]
-                .filter(Boolean)
-                .join('&&');
+                makeSimpleFilter(
+                    this.mapFilter(Object.fromEntries(this.requiredKeys.map(key => [key, '']))),
+                    '!='
+                );
+            const customFilter = !isEmpty(filter) && makeSimpleFilter(this.mapFilter(filter));
+
+            return [requiredFilter, customFilter].filter(Boolean).join('&&');
         }
 
         /**
@@ -118,13 +139,13 @@ export function BiDataTable<T extends DataObject, F extends Filter<T> = Filter<T
                           Object.entries(this.sort).map(([key, order]) => `${key} ${order}`)
                       )
                   };
-            const stream = createPageStream<TableRecord<T>>(
+            const stream = createPageStream<TableRecord<DataObject>>(
                 this.client,
                 this.baseURI,
                 total => (this.totalCount = total),
                 { ...searchParams, ...this.queryOptions }
             );
-            for await (const item of stream) yield this.normalize(item);
+            for await (const item of stream) yield this.mapFields(item);
         }
 
         async getViewList(
@@ -157,12 +178,11 @@ export type BiSearchFilter<D extends DataObject> = Filter<D> & {
 };
 
 export function BiSearch<D extends DataObject, F extends BiSearchFilter<D> = BiSearchFilter<D>>(
-    Model: Constructor<ListModel<D, F>>
+    Model: ReturnType<typeof BiDataTable<D, F>>
 ) {
     abstract class BiSearchModel extends Model {
         declare baseURI: string;
         declare client: RESTClient;
-        declare loadPage: (pageIndex: number, pageSize: number, filter: F) => Promise<PageData<D>>;
 
         abstract searchKeys: readonly (keyof TableRecordFields)[];
 
@@ -170,7 +190,9 @@ export function BiSearch<D extends DataObject, F extends BiSearchFilter<D> = BiS
         accessor keywords = '';
 
         makeFilter(filter: F) {
-            return isEmpty(filter) ? '' : makeSimpleFilter(filter, 'contains', 'OR');
+            return isEmpty(filter)
+                ? ''
+                : makeSimpleFilter(this.mapFilter(filter), 'contains', 'OR');
         }
 
         async getList(

package/src/module/BITable/utility.ts

@@ -1,10 +1,13 @@
 import { DataObject } from 'mobx-restful';
-import {
-    TableCellLink,
-    TableCellLocation,
-    TableCellRelation,
-    TableCellText
-} from './type';
+import { TableCellLink, TableCellLocation, TableCellRelation, TableCellText } from './type';
+
+export const mapKeys = <I extends DataObject, O extends DataObject>(
+    data: I,
+    map: Partial<Record<keyof I, PropertyKey>>
+) =>
+    Object.fromEntries(
+        Object.entries(data).map(([key, value]) => [map[key as keyof I] || key, value])
+    ) as O;
 
 export type FilterOperator = '<' | '<=' | '=' | '!=' | '=>' | '>' | 'contains';
 
@@ -34,9 +37,7 @@ export function makeSimpleFilter(
     return list[1] ? `${relation}(${list})` : list[0];
 }
 
-export const normalizeText = (
-    value: TableCellText | TableCellLink | TableCellRelation
-) =>
+export const normalizeText = (value: TableCellText | TableCellLink | TableCellRelation) =>
     (value && typeof value === 'object' && 'text' in value && value.text) || '';
 
 export const normalizeTextArray = (list: TableCellText[]) =>
@@ -50,8 +51,7 @@ export const normalizeTextArray = (list: TableCellText[]) =>
         ['']
     );
 export function coordinateOf(location: TableCellLocation): [number, number] {
-    const [longitude, latitude] =
-        (location as TableCellLocation)?.location.split(',') || [];
+    const [longitude, latitude] = (location as TableCellLocation)?.location.split(',') || [];
 
     return [+latitude, +longitude];
 }