新增 Airtable 相關的 DTO 介面，並重構 BaseService 和 HttpService 以支援 API 操作

Author: thomascsd

src/dtos/AirTableCreateMapping.ts

@@ -0,0 +1,5 @@
+export interface AirtableCreateMapping {
+  id: string;
+  fields: Record<string, unknown>;
+  createdTime: string;
+}

src/dtos/AirTableDeleteMapping.ts

@@ -0,0 +1,4 @@
+export interface AirtableDeleteMapping {
+  id: string;
+  deleted: boolean;
+}

src/dtos/AirTableListMapping.ts

@@ -0,0 +1,11 @@
+export interface AirtableListMapping {
+  offset?: string;
+  records: AirtableRecord[];
+}
+
+export interface AirtableRecord {
+  id: string;
+  fields: Record<string, unknown>;
+  createdTime: string;
+  commentCount?: number;
+}

src/dtos/SelectOptions.ts

@@ -0,0 +1,8 @@
+export interface SelectOptions {
+  fields?: string[];
+  filterByFormula?: string;
+  maxRecords?: number;
+  pageSize?: number;
+  sort?: string;
+  view?: string;
+}

src/dtos/airTableGetMapping.ts

@@ -0,0 +1,4 @@
+export * from './AirTableCreateMapping.js';
+export * from './AirTableListMapping.js';
+export * from './AirTableDeleteMapping.js';
+export * from './SelectOptions.js';

src/dtos/index.ts

@@ -1,23 +1,37 @@
-import AsyncAirtable from 'asyncairtable';
-import { AirtableRecord, DeleteResponse, SelectOptions } from 'asyncairtable/lib/@types';
 import { BaseModel } from '@thomascsd/stools-models';
+import { HttpService } from './HttpService.js';
+import { AirtableDeleteMapping, AirtableRecord, SelectOptions } from '../dtos/index.js';
 
 /**
- * Base class that access AitTable api
+ * Base class that accesses Airtable API
  *
  * @export
  * @class BaseService
  */
 export class BaseService {
-  constructor(public apiKey: string) {}
+  /**
+   * Creates an instance of BaseService.
+   */
+  constructor() {}
 
+  /**
+   * Retrieves records from a specified Airtable base and table.
+   *
+   * @template T
+   * @param {string} baseId - The ID of the Airtable base.
+   * @param {string} tableName - The name of the table.
+   * @param {SelectOptions} [options] - Optional query parameters.
+   * @returns {Promise<T[]>} - A promise that resolves to an array of records.
+   */
   protected async get<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     options?: SelectOptions
   ): Promise<T[]> {
-    const airtable = this.getAirTableClient(baseId);
-    const records: AirtableRecord[] = await airtable.select(tableName, options);
+    const airtable = this.getAirTableClient(token, baseId);
+    const mapping = await airtable.list(tableName);
+    const records = mapping.records;
 
     const body = records
       .map((o: AirtableRecord) => {
@@ -33,18 +47,23 @@ export class BaseService {
     return body;
   }
 
-  protected async save<T extends BaseModel>(baseId: string, tableName: string, model: T) {
-    const airtable = this.getAirTableClient(baseId);
-    const body = await airtable.createRecord(tableName, model);
+  protected async save<T extends BaseModel>(
+    token: string,
+    baseId: string,
+    tableName: string,
+    model: T
+  ) {
+    const airtable = this.getAirTableClient(token, baseId);
+    const body = await airtable.create(tableName, model);
     return body;
   }
 
-  async update<T extends BaseModel>(baseId: string, tableName: string, model: T) {
-    const airtable = this.getAirTableClient(baseId);
+  async update<T extends BaseModel>(token: string, baseId: string, tableName: string, model: T) {
+    const airtable = this.getAirTableClient(token, baseId);
     const tmpModel = { ...model };
     const id = tmpModel.id;
     delete tmpModel.id;
-    const body = await airtable.updateRecord(tableName, {
+    const body = await airtable.update(tableName, model.id as string, {
       id: id as string,
       fields: tmpModel,
     });
@@ -53,18 +72,19 @@ export class BaseService {
   }
 
   protected async delete<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     model: T
-  ): Promise<DeleteResponse> {
-    const airtable = this.getAirTableClient(baseId);
+  ): Promise<AirtableDeleteMapping> {
+    const airtable = this.getAirTableClient(token, baseId);
 
-    const res = await airtable.deleteRecord(tableName, model.id as string);
+    const res = await airtable.delete(tableName, model.id as string);
     return res;
   }
 
-  private getAirTableClient(baseId: string) {
-    const airtable = new AsyncAirtable(this.apiKey, baseId);
+  private getAirTableClient(token: string, baseId: string) {
+    const airtable = new HttpService(token, baseId);
 
     return airtable;
   }

src/services/BaseService.ts

@@ -1,6 +1,6 @@
-import { AirtableRecord, DeleteResponse, SelectOptions } from 'asyncairtable/lib/@types';
 import { BaseModel } from '@thomascsd/stools-models';
-import { BaseService } from './BaseService';
+import { BaseService } from './BaseService.js';
+import { AirtableCreateMapping, AirtableDeleteMapping, SelectOptions } from '../dtos/index.js';
 
 /**
  * Defines  service that access AirTable's data
@@ -10,23 +10,29 @@ import { BaseService } from './BaseService';
  * @extends {BaseService}
  */
 export class DataFunctionService extends BaseService {
-  constructor(public apiKey: string, public baseId: string) {
-    super(apiKey);
+  constructor(public token: string, public baseId: string) {
+    super();
   }
 
   async getDatas<T extends BaseModel>(tableName: string, options?: SelectOptions): Promise<T[]> {
-    return await super.get<T>(this.baseId, tableName, options);
+    return await super.get<T>(this.token, this.baseId, tableName, options);
   }
 
-  async saveData<T extends BaseModel>(tableName: string, model: T): Promise<AirtableRecord> {
-    return await super.save<T>(this.baseId, tableName, model);
+  async saveData<T extends BaseModel>(tableName: string, model: T): Promise<AirtableCreateMapping> {
+    return await super.save<T>(this.token, this.baseId, tableName, model);
   }
 
-  async updateData<T extends BaseModel>(tableName: string, model: T): Promise<AirtableRecord> {
-    return await super.update<T>(this.baseId, tableName, model);
+  async updateData<T extends BaseModel>(
+    tableName: string,
+    model: T
+  ): Promise<AirtableCreateMapping> {
+    return await super.update<T>(this.token, this.baseId, tableName, model);
   }
 
-  async deleteData<T extends BaseModel>(tableName: string, model: T): Promise<DeleteResponse> {
-    return await super.delete<T>(this.baseId, tableName, model);
+  async deleteData<T extends BaseModel>(
+    tableName: string,
+    model: T
+  ): Promise<AirtableDeleteMapping> {
+    return await super.delete<T>(this.token, this.baseId, tableName, model);
   }
 }

src/services/DataFunctionService.ts

@@ -1,26 +1,19 @@
-import { AirtableRecord, DeleteResponse, SelectOptions } from 'asyncairtable/lib/@types';
-import { Service, Inject, Token } from 'typedi';
+import { Service } from 'typedi';
 import { BaseModel } from '@thomascsd/stools-models';
-import { BaseService } from './BaseService';
-
-const AIRTABLE_APIKEY_TOKEN = 'stools_AIRTABLE_APIKEY_TOKEN';
-
-/**
- * Defines a token that get Airtable key
- */
-export const API_KEY_TOKEN = new Token<string>(AIRTABLE_APIKEY_TOKEN);
+import { BaseService } from './BaseService.js';
+import { AirtableCreateMapping, AirtableDeleteMapping, SelectOptions } from '../dtos/index.js';
 
 /**
- * Defines service that access AirTable's data, and use DI with typedi.
- * 
+ * Defines service that accesses AirTable's data, and uses DI with typedi.
+ *
  * ```typescript
  * import { Service, Container } from 'typedi';
  * import { DataService, BaseModel, API_KEY_TOKEN } from '@thomascsd/stools';
-
+ *
  * Container.set(API_KEY_TOKEN, process.env.<your api key>);
-
+ *
  * const BASE_ID = '<your base id>';
-
+ *
  * export class Contact extends BaseModel {
  *  name: string;
  *  email: string;
@@ -29,105 +22,109 @@ export const API_KEY_TOKEN = new Token<string>(AIRTABLE_APIKEY_TOKEN);
  *
  * @Service()
  * export class ContactService {
- * constructor(private db: DataService) {}
+ *   constructor(private db: DataService) {}
  *
- * async getContacts(): Promise<Contact[]> {
- *   return await this.db.getDatas<Contact>(BASE_ID, '<your table name of AirTable>');
- * }
+ *   async getContacts(): Promise<Contact[]> {
+ *     return await this.db.getDatas<Contact>(BASE_ID, '<your table name of AirTable>');
+ *   }
  *
- * async saveContact(contact: Contact) {
- *   return await this.db.saveData<Contact>(BASE_ID, '<your table name of AirTable>', contact);
- * }
+ *   async saveContact(contact: Contact) {
+ *     return await this.db.saveData<Contact>(BASE_ID, '<your table name of AirTable>', contact);
+ *   }
  *
- * async updateContact(contact: Contact) {
- *   return await this.db.updateData<Contact>(BASE_ID, '<your table name of AirTable>', contact);
- * }
+ *   async updateContact(contact: Contact) {
+ *     return await this.db.updateData<Contact>(BASE_ID, '<your table name of AirTable>', contact);
+ *   }
  * }
  * ```
- * 
+ *
  * @export
  * @class DataService
  * @extends {BaseService}
  */
 @Service()
 export class DataService extends BaseService {
-  constructor(@Inject(API_KEY_TOKEN) public apiKey: string) {
-    super(apiKey);
-
-    if (!this.apiKey) {
-      this.apiKey = process.env.AIRTABLE_API ?? '';
-    }
+  constructor() {
+    super();
   }
 
   /**
-   * Get Datas from AirTable
+   * Get data from AirTable
    *
    * @template T
-   * @param {string} baseId
-   * @param {string} tableName
-   * @param {SelectOptions} [options]
-   * @return {*}  {Promise<T[]>}
+   * @param {string} token - API token
+   * @param {string} baseId - Base ID of AirTable
+   * @param {string} tableName - Table name in AirTable
+   * @param {SelectOptions} [options] - Options for selecting data
+   * @return {Promise<T[]>} - Promise resolving to an array of data
    * @memberof DataService
    */
   async getDatas<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     options?: SelectOptions
   ): Promise<T[]> {
-    return await super.get<T>(baseId, tableName, options);
+    return await super.get<T>(token, baseId, tableName, options);
   }
 
   /**
-   * Insert data to Airtable
+   * Insert data into AirTable
    *
    * @template T
-   * @param {string} baseId
-   * @param {string} tableName
-   * @param {T} model
-   * @return {*}  {Promise<AirtableRecord>}
+   * @param {string} token - API token
+   * @param {string} baseId - Base ID of AirTable
+   * @param {string} tableName - Table name in AirTable
+   * @param {T} model - Data model to insert
+   * @return {Promise<AirtableCreateMapping>} - Promise resolving to the created record mapping
    * @memberof DataService
    */
   async saveData<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     model: T
-  ): Promise<AirtableRecord> {
-    return await super.save<T>(baseId, tableName, model);
+  ): Promise<AirtableCreateMapping> {
+    return await super.save<T>(token, baseId, tableName, model);
   }
 
   /**
-   * Update data to AirTable
+   * Update data in AirTable
    *
    * @template T
-   * @param {string} baseId
-   * @param {string} tableName
-   * @param {T} model
-   * @return {*}  {Promise<AirtableRecord>}
+   * @param {string} token - API token
+   * @param {string} baseId - Base ID of AirTable
+   * @param {string} tableName - Table name in AirTable
+   * @param {T} model - Data model to update
+   * @return {Promise<AirtableCreateMapping>} - Promise resolving to the updated record mapping
    * @memberof DataService
    */
   async updateData<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     model: T
-  ): Promise<AirtableRecord> {
-    return await super.update<T>(baseId, tableName, model);
+  ): Promise<AirtableCreateMapping> {
+    return await super.update<T>(token, baseId, tableName, model);
   }
 
   /**
    * Delete data from AirTable
    *
    * @template T
-   * @param {string} baseId
-   * @param {string} tableName
-   * @param {T} model
-   * @return {*}  {Promise<DeleteResponse>}
+   * @param {string} token - API token
+   * @param {string} baseId - Base ID of AirTable
+   * @param {string} tableName - Table name in AirTable
+   * @param {T} model - Data model to delete
+   * @return {Promise<AirtableDeleteMapping>} - Promise resolving to the deleted record mapping
    * @memberof DataService
    */
   async deleteData<T extends BaseModel>(
+    token: string,
     baseId: string,
     tableName: string,
     model: T
-  ): Promise<DeleteResponse> {
-    return await super.delete<T>(baseId, tableName, model);
+  ): Promise<AirtableDeleteMapping> {
+    return await super.delete<T>(token, baseId, tableName, model);
   }
 }