feat: add sdk

Author: nichenqin

src/Sdk.ts

@@ -0,0 +1,40 @@
+import ky, { type KyInstance } from 'ky'
+import { AuthService } from './services/auth.service'
+import { BaseService } from './services/base.service'
+import { OpenApiService } from './services/openapi.service'
+
+interface SDKOptions {
+  baseURL: string
+  fetch?: typeof fetch
+}
+
+export class UndbSDK {
+  private client: KyInstance
+  private authService: AuthService
+  private baseCache: Map<string, BaseService> = new Map()
+  private openApiService: OpenApiService
+
+  constructor(options: SDKOptions) {
+    const { baseURL, fetch: fetchFn } = options
+    this.client = ky.create({ prefixUrl: baseURL, credentials: 'include', fetch: fetchFn })
+    this.authService = new AuthService(this.client)
+    this.openApiService = new OpenApiService(baseURL, this.authService, fetchFn)
+  }
+
+  get auth() {
+    return this.authService
+  }
+
+  base(baseName: string): BaseService {
+    if (!this.baseCache.has(baseName)) {
+      const baseService = new BaseService(this.client, baseName, this.authService)
+      this.baseCache.set(baseName, baseService)
+    }
+    // biome-ignore lint/style/noNonNullAssertion: Cache is not null
+    return this.baseCache.get(baseName)!
+  }
+
+  getOpenapiClient<Paths extends {}>() {
+    return this.openApiService.getClient<Paths>()
+  }
+}

src/index.ts

@@ -1 +1,3 @@
-export { Client, type OpenApiClient } from './Client'
+export { type Client as OpenApiClient } from 'openapi-fetch'
+export { Client } from './Client'
+export { UndbSDK } from './Sdk'

src/services/auth.service.ts

@@ -0,0 +1,47 @@
+import type { KyInstance } from 'ky'
+
+interface AuthResponse {
+  user: {
+    id: string
+    email: string
+  }
+}
+
+export class AuthService {
+  private client: KyInstance
+  private token: string | null = null
+  private isUsingCookie = false
+
+  constructor(client: KyInstance) {
+    this.client = client
+  }
+
+  async loginWithEmail(email: string, password: string): Promise<AuthResponse> {
+    if (this.token) {
+      throw new Error('Already authenticated with API token.')
+    }
+    const response = await this.client.post('auth/login', { json: { email, password } }).json<AuthResponse>()
+    this.isUsingCookie = true
+    return response
+  }
+
+  setToken(token: string) {
+    if (this.isUsingCookie) {
+      throw new Error('Already authenticated with email and password.')
+    }
+    this.token = token
+    this.client = this.client.extend({
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+      },
+    })
+  }
+
+  getToken(): string | null {
+    return this.token
+  }
+
+  isAuthenticated(): boolean {
+    return this.token !== null || this.isUsingCookie
+  }
+}

src/services/base.service.ts

@@ -0,0 +1,26 @@
+import type { KyInstance } from 'ky'
+import type { AuthService } from './auth.service'
+import { TableService } from './table.service'
+
+export class BaseService {
+  private client: KyInstance
+  private baseName: string
+  private authService: AuthService
+  private tableCache: Map<string, TableService> = new Map()
+
+  constructor(client: KyInstance, baseName: string, authService: AuthService) {
+    this.client = client
+    this.baseName = baseName
+    this.authService = authService
+  }
+
+  table(tableName: string, viewName?: string): TableService {
+    const cacheKey = `${tableName}:${viewName || ''}`
+    if (!this.tableCache.has(cacheKey)) {
+      const tableService = new TableService(this.client, this.baseName, tableName, this.authService, viewName)
+      this.tableCache.set(cacheKey, tableService)
+    }
+    // biome-ignore lint/style/noNonNullAssertion: Cache is always set
+    return this.tableCache.get(cacheKey)!
+  }
+}

src/services/openapi.service.ts

@@ -0,0 +1,31 @@
+import createClient, { type Client } from 'openapi-fetch'
+import type { AuthService } from './auth.service'
+
+export class OpenApiService {
+  private authService: AuthService
+  private baseUrl: string
+  private fetchFn?: typeof fetch
+
+  constructor(baseUrl: string, authService: AuthService, fetchFn?: typeof fetch) {
+    this.authService = authService
+    this.baseUrl = baseUrl
+    this.fetchFn = fetchFn
+  }
+
+  getClient<Paths extends {}>(): Client<Paths> {
+    const client = createClient<Paths>({
+      baseUrl: this.baseUrl,
+      fetch: this.fetchFn,
+    })
+
+    client.use({
+      onRequest: ({ request }) => {
+        const token = this.authService.getToken()
+        if (token) {
+          request.headers.set('X-Undb-Api-Token', token)
+        }
+      },
+    })
+    return client
+  }
+}

src/services/table.service.ts

@@ -0,0 +1,67 @@
+import type { KyInstance } from 'ky'
+import type { AuthService } from './auth.service'
+
+interface IRecord {
+  id: string
+  values: Record<string, unknown>
+}
+
+interface CreateRecordPayload {
+  values: Record<string, unknown>
+}
+
+interface UpdateRecordPayload {
+  values: Record<string, unknown>
+}
+
+export class TableService {
+  private client: KyInstance
+  private baseName: string
+  private tableName: string
+  private viewName?: string
+  private authService: AuthService
+
+  constructor(client: KyInstance, baseName: string, tableName: string, authService: AuthService, viewName?: string) {
+    this.client = client
+    this.baseName = baseName
+    this.tableName = tableName
+    this.viewName = viewName
+    this.authService = authService
+  }
+
+  private checkAuth() {
+    if (!this.authService.isAuthenticated()) {
+      throw new Error('Authentication is missing. Please login first.')
+    }
+  }
+
+  private getUrl(path: string): string {
+    if (this.viewName) {
+      return `bases/${this.baseName}/tables/${this.tableName}/views/${this.viewName}/${path}`
+    }
+    return `bases/${this.baseName}/tables/${this.tableName}/${path}`
+  }
+
+  async getRecords(): Promise<IRecord[]> {
+    this.checkAuth()
+    const response = await this.client.get(this.getUrl('records')).json<{ records: IRecord[] }>()
+    return response.records
+  }
+
+  async createRecord(payload: CreateRecordPayload): Promise<IRecord> {
+    this.checkAuth()
+    const response = await this.client.post(this.getUrl('records'), { json: payload }).json<IRecord>()
+    return response
+  }
+
+  async updateRecord(recordId: string, payload: UpdateRecordPayload): Promise<IRecord> {
+    this.checkAuth()
+    const response = await this.client.patch(this.getUrl(`records/${recordId}`), { json: payload }).json<IRecord>()
+    return response
+  }
+
+  async deleteRecord(recordId: string): Promise<void> {
+    this.checkAuth()
+    await this.client.delete(this.getUrl(`records/${recordId}`))
+  }
+}

test/Sdk.test.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, jest } from 'bun:test'
+import { UndbSDK } from '../src/Sdk'
+import { AuthService } from '../src/services/auth.service'
+import { BaseService } from '../src/services/base.service'
+
+describe('UndbSDK', () => {
+  const baseURL = 'http://example.com'
+  const fetchFn = jest.fn()
+
+  let sdk: UndbSDK
+
+  beforeEach(() => {
+    sdk = new UndbSDK({ baseURL, fetch: fetchFn })
+  })
+
+  it('should initialize authService and openApiService', () => {
+    expect(sdk.auth).toBeInstanceOf(AuthService)
+    // getOpenapiClient() 返回的不是 OpenApiService 实例，而是一个由 OpenApiService 创建的客户端
+    expect(sdk.getOpenapiClient()).toBeDefined()
+    expect(typeof sdk.getOpenapiClient()).toBe('object')
+  })
+
+  it('should return authService instance', () => {
+    const authService = sdk.auth
+    expect(authService).toBeInstanceOf(AuthService)
+  })
+
+  it('should return a BaseService instance from base method', () => {
+    const baseName = 'testBase'
+    const baseService = sdk.base(baseName)
+    expect(baseService).toBeInstanceOf(BaseService)
+    expect(sdk.base(baseName)).toBe(baseService) // should return the same instance from cache
+  })
+
+  it('should return an OpenApi client', () => {
+    const client = sdk.getOpenapiClient()
+    expect(client).toBeDefined()
+  })
+})

test/template.test.ts

@@ -1,14 +1,15 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, jest, test } from 'bun:test'
 import { http, HttpResponse } from 'msw'
 import { setupServer } from 'msw/node'
-import { Client, OpenApiClient } from '../src/Client'
+import type { OpenApiClient } from '../src'
+import { UndbSDK } from '../src/Sdk'
 import type { components, paths } from './templates'
 
 const SECRET = 'secret'
 const BASE_URL = 'http://localhost:3721/api'
 
 describe('template', () => {
-  let client: Client
+  let sdk: UndbSDK
   let openapi: OpenApiClient<paths>
 
   let mockFetch: jest.Mock
@@ -19,9 +20,9 @@ describe('template', () => {
         headers: new Headers(),
         text: async () => '',
       }))
-      client = new Client({ baseUrl: BASE_URL, fetch: mockFetch })
-      client.setSecret(SECRET)
-      openapi = client.openapi<paths>()
+      sdk = new UndbSDK({ baseURL: BASE_URL, fetch: mockFetch })
+      sdk.auth.setToken(SECRET)
+      openapi = sdk.getOpenapiClient<paths>()
     })
 
     afterEach(() => {
@@ -64,8 +65,9 @@ describe('template', () => {
     beforeEach(() => {
       // NOTE: server.listen must be called before `createClient` is used to ensure
       // the msw can inject its version of `fetch` to intercept the requests.
-      client = new Client({ baseUrl: BASE_URL })
-      openapi = client.openapi<paths>()
+      sdk = new UndbSDK({ baseURL: BASE_URL })
+      sdk.auth.setToken(SECRET)
+      openapi = sdk.getOpenapiClient<paths>()
     })
 
     afterEach(() => server.resetHandlers())