mobx-lark 2.8.0 → 2.9.0

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(
@@ -156,13 +177,14 @@ export type BiSearchFilter<D extends DataObject> = Filter<D> & {
     keywords?: string;
 };
 
-export function BiSearch<D extends DataObject, F extends BiSearchFilter<D> = BiSearchFilter<D>>(
-    Model: Constructor<ListModel<D, F>>
-) {
-    abstract class BiSearchModel extends Model {
+export function BiSearch<
+    D extends DataObject,
+    F extends BiSearchFilter<D> = BiSearchFilter<D>,
+    M extends ReturnType<typeof BiDataTable<D, F>> = ReturnType<typeof BiDataTable<D, F>>
+>(Model: M) {
+    abstract class BiSearchModel extends (Model as ReturnType<typeof BiDataTable<D, F>>) {
         declare baseURI: string;
         declare client: RESTClient;
-        declare loadPage: (pageIndex: number, pageSize: number, filter: F) => Promise<PageData<D>>;
 
         abstract searchKeys: readonly (keyof TableRecordFields)[];
 
@@ -170,7 +192,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];
 }

package/src/module/DocumentAI/index.ts

@@ -1,8 +1,16 @@
-import { makeFormData } from 'koajax';
+import { makeFormData, readAs } from 'koajax';
 import { BaseModel, RESTClient, toggle } from 'mobx-restful';
 
 import { LarkData } from '../../type';
-import { TaxiInvoice, TrainInvoice, VatInvoice, VehicleInvoice } from './type';
+import {
+    BankCardEntity,
+    Contract,
+    Resume,
+    TaxiInvoice,
+    TrainInvoice,
+    VatInvoice,
+    VehicleInvoice
+} from './type';
 
 export * from './type';
 
@@ -58,4 +66,60 @@ export abstract class DocumentAIModel extends BaseModel {
 
         return body!.data!.vehicle_invoice;
     }
+
+    /**
+     * @see {@link https://open.feishu.cn/document/server-docs/ai/optical_char_recognition-v1/basic_recognize}
+     */
+    @toggle('uploading')
+    async recognizeText(image: File) {
+        const URI = (await readAs(image, 'dataURL').result) as string;
+
+        const [, base64] = URI.split(',');
+
+        const { body } = await this.client.post<LarkData<{ text_list: string[] }>>(
+            'optical_char_recognition/v1/image/basic_recognize',
+            { image: base64 }
+        );
+        return body!.data!.text_list;
+    }
+
+    /**
+     * @see {@link https://open.feishu.cn/document/ai/document_ai-v1/bank_card/recognize}
+     */
+    @toggle('uploading')
+    async recognizeBankCard(file: File) {
+        const { body } = await this.client.post<
+            LarkData<{ bank_card: { entities: BankCardEntity[] } }>
+        >(`${this.baseURI}/bank_card/recognize`, makeFormData({ file }));
+
+        return body!.data!.bank_card.entities;
+    }
+
+    /**
+     * @see {@link https://open.feishu.cn/document/ai/document_ai-v1/resume/parse}
+     */
+    @toggle('uploading')
+    async parseResume(file: File) {
+        const { body } = await this.client.post<LarkData<{ resumes: Resume[] }>>(
+            `${this.baseURI}/resume/parse`,
+            makeFormData({ file })
+        );
+        return body!.data!.resumes;
+    }
+
+    /**
+     * @see {@link https://open.feishu.cn/document/server-docs/ai/document_ai-v1/contract/field_extraction}
+     */
+    @toggle('uploading')
+    async extractContract(
+        file: File,
+        ocr_mode: 'unused' | 'force' | 'auto' = 'auto',
+        pdf_page_limit = 100
+    ) {
+        const { body } = await this.client.post<LarkData<Contract>>(
+            `${this.baseURI}/contract/field_extraction`,
+            makeFormData({ file, ocr_mode, pdf_page_limit })
+        );
+        return body!.data!;
+    }
 }

package/src/module/DocumentAI/type.ts

@@ -1,3 +1,5 @@
+import { Gender } from '../User/type';
+
 export type InvoiceEntityType =
     | `invoice_${'code' | 'no' | 'special_seal'}`
     | `seller_${'name' | 'taxpayer_no'}_in_seal`;
@@ -67,3 +69,130 @@ export interface VehicleInvoice {
         | `total_price${'' | '_little'}`;
     value: string;
 }
+
+export interface BankCardEntity {
+    type: 'card_number' | 'date_of_expiry';
+    value: string;
+}
+
+export type ResumePeriod = Record<`${'start' | 'end'}_${'date' | 'time'}`, string>;
+
+export enum EducationQualification {
+    PrimarySchool = 1,
+    JuniorHighSchool = 2,
+    VocationalHighSchool = 3,
+    HighSchool = 4,
+    AssociateDegree = 5,
+    BachelorDegree = 6,
+    MasterDegree = 7,
+    Doctorate = 8,
+    Other = 9
+}
+
+export interface ResumeEducation
+    extends ResumePeriod, Record<'school' | 'major' | 'degree', string> {
+    qualification: EducationQualification;
+}
+
+export enum CareerType {
+    Internship = 1,
+    FullTime = 2
+}
+
+export interface ResumeCareer
+    extends ResumePeriod, Record<'company' | 'title' | 'type_str' | 'job_description', string> {
+    type: CareerType;
+}
+
+export type ResumeProject = ResumePeriod & Record<'name' | 'title' | 'description', string>;
+
+export interface ResumeLanguage {
+    level: number;
+    description: string;
+}
+
+export type ResumeAward = Record<'award' | 'date' | 'description', string>;
+
+export type ResumeCertificate = Record<'name' | 'desc', string>;
+
+export type ResumeCompetition = ResumeCertificate;
+
+export interface Resume
+    extends
+        Record<
+            | 'file_md5'
+            | `${'' | 'new_'}content`
+            | 'name'
+            | 'email'
+            | 'mobile'
+            | 'country_code'
+            | 'date_of_birth'
+            | `${'current' | 'home'}_location`
+            | 'self_evaluation',
+            string
+        >,
+        Record<`willing_${'positions' | 'locations'}` | 'urls' | 'social_links', string[]> {
+    mobile_is_virtual: boolean;
+    educations: ResumeEducation[];
+    careers: ResumeCareer[];
+    projects: ResumeProject[];
+    work_year: number | null;
+    gender: Gender;
+    languages: ResumeLanguage[];
+    awards: ResumeAward[];
+    certificates: ResumeCertificate[];
+    competitions: ResumeCompetition[];
+}
+
+export interface ContractPrice {
+    contract_price: number;
+    contract_price_original: string;
+    text: string;
+}
+
+export type ContractInitialTerm = Record<`initial_${'time' | 'unit'}`, string>;
+
+export interface ContractTime extends Record<
+    `${'' | 'original_'}time_${'start' | 'end'}` | `text_${'start' | 'end' | 'initial_term'}`,
+    string
+> {
+    initial_term: ContractInitialTerm;
+}
+
+export interface ContractCopy extends Record<'original_copy' | 'key' | 'text', string> {
+    copy_num: number;
+}
+
+export type ContractCurrency = Record<`currency_${'name' | 'text'}`, string>;
+
+export type ContractBodyType = 'buy' | 'sell' | 'third';
+
+export type ContractContact = Record<
+    'contacts' | 'id_number' | 'phone' | 'email' | 'address',
+    string
+>;
+export type ContractBodyEntity = ContractContact & Record<'legal_representative' | 'party', string>;
+
+export interface ContractBodyInfo {
+    body_type: ContractBodyType;
+    value: ContractBodyEntity;
+}
+
+export type ContractBankType = `${'buy' | 'sell' | 'third' | 'uncertain'}_bank`;
+
+export type ContractBankEntity = ContractContact &
+    Record<'bank_name' | `account_${'name' | 'number'}` | 'tax_number', string>;
+
+export interface ContractBankInfo {
+    bank_type: ContractBankType;
+    value: ContractBankEntity;
+}
+
+export interface Contract extends Record<'file_id' | 'header', string> {
+    price: ContractPrice;
+    time: ContractTime;
+    copy: ContractCopy;
+    currency: ContractCurrency;
+    body_info: ContractBodyInfo[];
+    bank_info: ContractBankInfo[];
+}