@ikatec/digisac-api-sdk 4.0.0 → 4.2.0

package/src/core/withQueryFormat.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from './ApiClient'
+import { BaseApiClient } from './BaseApiClient'
+import { BaseCrudApi } from './BaseCrudApi'
+import { StickerUsersApi } from '../apis/stickerUsers/StickerUsersApi'
+import { TermsApi } from '../apis/terms/TermsApi'
+
+type Item = { id: string; name: string }
+
+class ItemsApi extends BaseCrudApi<Item, { name: string }> {
+  constructor(client: ApiClient) {
+    super(client, '/items')
+    this.searchByName = this.searchByName.bind(this)
+  }
+
+  searchByName(name: string) {
+    return this.getMany({ where: { name }, paginate: false })
+  }
+}
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn().mockResolvedValue([]),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const calledUrl = (client: ApiClient, call = 0) =>
+  decodeURIComponent(vi.mocked(client.get).mock.calls.at(call)?.at(0) as string)
+
+const JSON_QUERY = '/items?query={"where":{"name":"x"},"paginate":false}'
+const QS_QUERY = '/items?where[name]=x&paginate=false'
+
+describe('withQueryFormat', () => {
+  let client: ApiClient
+  let api: ItemsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new ItemsApi(client)
+  })
+
+  it('returns a copy that uses the given format', async () => {
+    await api.withQueryFormat('qs').getMany({ where: { name: 'x' }, paginate: false })
+    expect(calledUrl(client)).toBe(QS_QUERY)
+  })
+
+  it('leaves the original API unchanged', async () => {
+    api.withQueryFormat('qs')
+    await api.getMany({ where: { name: 'x' }, paginate: false })
+    expect(calledUrl(client)).toBe(JSON_QUERY)
+    expect(api.client).toBe(client)
+  })
+
+  it('keeps the class, basePath and fields', () => {
+    const copy = api.withQueryFormat('qs')
+    expect(copy).toBeInstanceOf(ItemsApi)
+    expect(copy).toBeInstanceOf(BaseCrudApi)
+    expect(copy.basePath).toBe('/items')
+    expect(copy).not.toBe(api)
+  })
+
+  it('binds destructured methods to the copy', async () => {
+    const { getMany, getOne, getById } = api.withQueryFormat('qs')
+    await getMany({ where: { name: 'x' }, paginate: false })
+    await getOne({ where: { name: 'x' } })
+    await getById('1', { attributes: ['id'] })
+    expect(calledUrl(client, 0)).toBe(QS_QUERY)
+    expect(calledUrl(client, 1)).toBe('/items?where[name]=x&limit=1&paginate=false')
+    expect(calledUrl(client, 2)).toBe('/items/1?attributes[0]=id')
+  })
+
+  it('rebinds methods bound by subclass constructors', async () => {
+    const { searchByName } = api.withQueryFormat('qs')
+    await searchByName('x')
+    expect(calledUrl(client)).toBe(QS_QUERY)
+  })
+
+  it('can be chained again', async () => {
+    await api.withQueryFormat('qs').withQueryFormat('json').searchByName('x')
+    expect(calledUrl(client)).toBe(JSON_QUERY)
+  })
+
+  it('overrides a qs client back to json', async () => {
+    const qsApi = new ItemsApi(Object.assign(createMockClient(), { queryFormat: 'qs' as const }))
+    await qsApi.withQueryFormat('json').searchByName('x')
+    expect(calledUrl(qsApi.client)).toBe(JSON_QUERY)
+  })
+
+  it('still sends requests through the original client', async () => {
+    const copy = api.withQueryFormat('qs')
+    await copy.create({ name: 'x' })
+    expect(client.post).toHaveBeenCalledWith('/items', { name: 'x' }, undefined)
+    expect(copy.client.queryFormat).toBe('qs')
+    expect(client.queryFormat).toBeUndefined()
+  })
+
+  it('works on APIs that do not extend BaseCrudApi', async () => {
+    await new StickerUsersApi(client).withQueryFormat('qs').getMany({ page: 2 })
+    await new TermsApi(client).withQueryFormat('qs').getById('t1', { attributes: ['id'] })
+    expect(calledUrl(client, 0)).toBe('/sticker-users?page=2')
+    expect(calledUrl(client, 1)).toBe('/terms/t1?attributes[0]=id')
+  })
+
+  describe('with BaseApiClient', () => {
+    afterEach(() => {
+      vi.restoreAllMocks()
+    })
+
+    const mockFetch = () =>
+      vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(
+          new Response('[]', { status: 200, headers: { 'Content-Type': 'application/json' } }),
+        )
+
+    it('uses the base URL and a token set on the original client after copying', async () => {
+      const fetchSpy = mockFetch()
+      const baseClient = new BaseApiClient('https://api.example.com', 'old-token')
+      const copy = new ItemsApi(baseClient).withQueryFormat('qs')
+      baseClient.setAccessToken('new-token')
+
+      await copy.searchByName('x')
+
+      const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit]
+      expect(decodeURIComponent(url)).toBe(`https://api.example.com${QS_QUERY}`)
+      expect((init.headers as Record<string, string>).Authorization).toBe('Bearer new-token')
+      expect(baseClient.queryFormat).toBe('json')
+    })
+  })
+})

package/src/core/withQueryFormat.ts

@@ -0,0 +1,47 @@
+import type { ApiClient } from './ApiClient'
+import type { QueryFormat } from './queryString'
+
+/**
+ * A view of `client` that serializes queries in `format`. Everything else — methods, base URL and
+ * the access token — is read from `client`, so `client.setAccessToken()` still applies to it.
+ */
+function overrideQueryFormat<T extends ApiClient>(client: T, format: QueryFormat): T {
+  return Object.create(client, {
+    queryFormat: { value: format, enumerable: true, configurable: true },
+  })
+}
+
+/**
+ * Copy of `api` whose client serializes queries in `format`; `api` itself is untouched.
+ *
+ * The copy has the same prototype and fields as `api`, with `client` replaced. Methods the
+ * constructor bound to `api` (`this.getMany = this.getMany.bind(this)`) are bound again to the
+ * copy, so they use its client.
+ */
+export function cloneWithQueryFormat<T extends object>(api: T, format: QueryFormat): T {
+  const source = api as T & { client: ApiClient }
+  const prototype = Object.getPrototypeOf(api) as Record<PropertyKey, unknown>
+  const copy = Object.create(prototype) as Record<PropertyKey, unknown>
+
+  for (const key of Reflect.ownKeys(api)) {
+    Object.defineProperty(
+      copy,
+      key,
+      Object.getOwnPropertyDescriptor(api, key) as PropertyDescriptor,
+    )
+  }
+  Object.defineProperty(copy, 'client', {
+    value: overrideQueryFormat(source.client, format),
+    enumerable: true,
+    configurable: true,
+    writable: false,
+  })
+  for (const key of Reflect.ownKeys(api)) {
+    const method = prototype[key]
+    if (typeof copy[key] === 'function' && typeof method === 'function') {
+      copy[key] = method.bind(copy)
+    }
+  }
+
+  return copy as T
+}