@devup-api/fetch 0.1.0

package/src/__tests__/url-map.test.ts

@@ -0,0 +1,182 @@
+import { expect, test } from 'bun:test'
+
+const urlMap = {
+  getUsers: { method: 'GET' as const, url: '/users' },
+  createUser: { method: 'POST' as const, url: '/users' },
+  updateUser: { method: 'PUT' as const, url: '/users/{id}' },
+  deleteUser: { method: 'DELETE' as const, url: '/users/{id}' },
+}
+
+test.each([
+  ['getUsers', '/users', JSON.stringify(urlMap)],
+  ['createUser', '/users', JSON.stringify(urlMap)],
+  ['updateUser', '/users/{id}', JSON.stringify(urlMap)],
+  ['deleteUser', '/users/{id}', JSON.stringify(urlMap)],
+] as const)('getUrl returns url for existing key: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  // Add query parameter to bypass module cache and reload
+  const { getUrl } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrl(key)).toBe(expected)
+})
+
+test.each([
+  ['nonExistentKey', 'nonExistentKey', JSON.stringify(urlMap)],
+  ['unknown', 'unknown', JSON.stringify(urlMap)],
+  ['', '', JSON.stringify(urlMap)],
+  ['/users', '/users', JSON.stringify(urlMap)],
+] as const)('getUrl returns key itself when key does not exist: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  const { getUrl } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrl(key)).toBe(expected)
+})
+
+test.each([
+  ['getUsers', { method: 'GET', url: '/users' }, JSON.stringify(urlMap)],
+  ['createUser', { method: 'POST', url: '/users' }, JSON.stringify(urlMap)],
+  ['updateUser', { method: 'PUT', url: '/users/{id}' }, JSON.stringify(urlMap)],
+  [
+    'deleteUser',
+    { method: 'DELETE', url: '/users/{id}' },
+    JSON.stringify(urlMap),
+  ],
+] as const)('getUrlWithMethod returns UrlMapValue for existing key: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  const { getUrlWithMethod } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrlWithMethod(key)).toEqual(expected)
+})
+
+test.each([
+  [
+    'nonExistentKey',
+    { method: 'GET', url: 'nonExistentKey' },
+    JSON.stringify(urlMap),
+  ],
+  ['unknown', { method: 'GET', url: 'unknown' }, JSON.stringify(urlMap)],
+  ['', { method: 'GET', url: '' }, JSON.stringify(urlMap)],
+  ['/users', { method: 'GET', url: '/users' }, JSON.stringify(urlMap)],
+] as const)('getUrlWithMethod returns default for non-existent key: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  const { getUrlWithMethod } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrlWithMethod(key)).toEqual(expected)
+})
+
+test.each([
+  ['anyKey', 'anyKey', '{}'],
+  ['test', 'test', '{}'],
+] as const)('getUrl works with empty URL map: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  const { getUrl } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrl(key)).toBe(expected)
+})
+
+test.each([
+  ['anyKey', { method: 'GET', url: 'anyKey' }, '{}'],
+  ['test', { method: 'GET', url: 'test' }, '{}'],
+] as const)('getUrlWithMethod works with empty URL map: %s -> %s', async (key, expected, envValue) => {
+  process.env.DEVUP_API_URL_MAP = envValue
+  const { getUrlWithMethod } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrlWithMethod(key)).toEqual(expected)
+})
+
+test.each([
+  ['anyKey', 'anyKey'],
+  ['test', 'test'],
+] as const)('getUrl works when DEVUP_API_URL_MAP is not set: %s -> %s', async (key, expected) => {
+  delete process.env.DEVUP_API_URL_MAP
+  const { getUrl } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrl(key)).toBe(expected)
+})
+
+test.each([
+  ['anyKey', { method: 'GET', url: 'anyKey' }],
+  ['test', { method: 'GET', url: 'test' }],
+] as const)('getUrlWithMethod works when DEVUP_API_URL_MAP is not set: %s -> %s', async (key, expected) => {
+  delete process.env.DEVUP_API_URL_MAP
+  const { getUrlWithMethod } = await import(`../url-map?t=${Date.now()}`)
+  expect(getUrlWithMethod(key)).toEqual(expected)
+})
+
+test('getUrl handles key that exists but url property is missing', async () => {
+  const urlMapWithoutUrl = {
+    testKey: { method: 'GET' as const },
+  }
+  process.env.DEVUP_API_URL_MAP = JSON.stringify(urlMapWithoutUrl)
+  const { getUrl } = await import(`../url-map?t=${Date.now() + Math.random()}`)
+  // When url property is missing, optional chaining returns undefined, so key is returned
+  expect(getUrl('testKey')).toBe('testKey')
+})
+
+test('DEVUP_API_URL_MAP constant is exported and accessible', async () => {
+  const testUrlMap = { testKey: { method: 'GET' as const, url: '/test' } }
+  process.env.DEVUP_API_URL_MAP = JSON.stringify(testUrlMap)
+  const urlMapModule = await import(
+    `../url-map?t=${Date.now() + Math.random()}`
+  )
+  expect(urlMapModule).toHaveProperty('DEVUP_API_URL_MAP')
+  expect(typeof urlMapModule.DEVUP_API_URL_MAP).toBe('object')
+  // Directly access the constant to ensure it's covered
+  const urlMap = urlMapModule.DEVUP_API_URL_MAP
+  expect(urlMap).toEqual(testUrlMap)
+  // Verify it's used by getUrl function
+  expect(urlMapModule.getUrl('testKey')).toBe('/test')
+})
+
+test('DEVUP_API_URL_MAP uses fallback when env var is undefined', async () => {
+  delete process.env.DEVUP_API_URL_MAP
+  const urlMapModule = await import(
+    `../url-map?t=${Date.now() + Math.random()}`
+  )
+  // Directly access the constant to ensure the fallback path is covered
+  const urlMap = urlMapModule.DEVUP_API_URL_MAP
+  expect(urlMap).toEqual({})
+  expect(urlMapModule.getUrl('anyKey')).toBe('anyKey')
+  expect(urlMapModule.getUrlWithMethod('anyKey')).toEqual({
+    method: 'GET',
+    url: 'anyKey',
+  })
+})
+
+test('DEVUP_API_URL_MAP uses fallback when env var is empty string', async () => {
+  process.env.DEVUP_API_URL_MAP = ''
+  const urlMapModule = await import(
+    `../url-map?t=${Date.now() + Math.random()}`
+  )
+  // Directly access the constant to ensure the fallback path is covered
+  const urlMap = urlMapModule.DEVUP_API_URL_MAP
+  expect(urlMap).toEqual({})
+  expect(urlMapModule.getUrl('anyKey')).toBe('anyKey')
+  expect(urlMapModule.getUrlWithMethod('anyKey')).toEqual({
+    method: 'GET',
+    url: 'anyKey',
+  })
+})
+
+test('getUrl handles key where DEVUP_API_URL_MAP[key] exists but url is undefined', async () => {
+  const urlMapWithUndefinedUrl = {
+    testKey: { method: 'GET' as const },
+  }
+  process.env.DEVUP_API_URL_MAP = JSON.stringify(urlMapWithUndefinedUrl)
+  const { getUrl } = await import(`../url-map?t=${Date.now() + Math.random()}`)
+  // When url property is missing, optional chaining returns undefined, so key is returned
+  expect(getUrl('testKey')).toBe('testKey')
+})
+
+test('getUrl handles key where DEVUP_API_URL_MAP[key] exists but url is null', async () => {
+  const urlMapWithNullUrl = {
+    testKey: { method: 'GET' as const, url: null as unknown as string },
+  }
+  process.env.DEVUP_API_URL_MAP = JSON.stringify(urlMapWithNullUrl)
+  const { getUrl } = await import(`../url-map?t=${Date.now() + Math.random()}`)
+  // When url is null, optional chaining returns null, so key is returned
+  expect(getUrl('testKey')).toBe('testKey')
+})
+
+test('getUrl handles key where DEVUP_API_URL_MAP[key] exists but url is empty string', async () => {
+  const urlMapWithEmptyUrl = {
+    testKey: { method: 'GET' as const, url: '' },
+  }
+  process.env.DEVUP_API_URL_MAP = JSON.stringify(urlMapWithEmptyUrl)
+  const { getUrl } = await import(`../url-map?t=${Date.now() + Math.random()}`)
+  // When url is empty string, it's falsy, so key is returned
+  expect(getUrl('testKey')).toBe('testKey')
+})

package/src/__tests__/utils.test.ts

@@ -0,0 +1,108 @@
+import { expect, test } from 'bun:test'
+import { getApiEndpoint, isPlainObject } from '../utils'
+
+test.each([
+  [{}, true],
+  [{ a: 1 }, true],
+  [{ a: 1, b: 'test' }, true],
+  [{ nested: { value: 1 } }, true],
+])('returns true for plain objects: %s', (obj, expected) => {
+  expect(isPlainObject(obj)).toBe(expected)
+})
+
+test.each([
+  [null, false],
+  [undefined, false],
+  [[], false],
+  [[1, 2, 3], false],
+  [new Date(), false],
+  [/test/, false],
+  [new Map(), false],
+  [new Set(), false],
+  ['string', false],
+  [123, false],
+  [true, false],
+  [false, false],
+  [() => {}, false],
+  [function test() {}, false],
+])('returns false for non-plain objects: %s', (obj, expected) => {
+  expect(isPlainObject(obj)).toBe(expected)
+})
+
+test.each([
+  [Object.create(null), false, 'Object.create(null)'],
+  [Object.create(Object.prototype), true, 'Object.create(Object.prototype)'],
+])('handles special object creation: %s', (obj, expected) => {
+  expect(isPlainObject(obj)).toBe(expected)
+})
+
+test.each([
+  [
+    (() => {
+      class TestClass {
+        value = 1
+      }
+      return new TestClass()
+    })(),
+    false,
+    'class instance',
+  ],
+  [
+    (() => {
+      const proto = { customProp: 'value' }
+      return Object.create(proto)
+    })(),
+    false,
+    'object with custom prototype',
+  ],
+])('returns false for non-plain objects: %s', (obj, expected) => {
+  expect(isPlainObject(obj)).toBe(expected)
+})
+
+test.each([
+  [
+    'https://api.example.com',
+    '/users',
+    undefined,
+    'https://api.example.com/users',
+  ],
+  ['https://api.example.com', '/users', {}, 'https://api.example.com/users'],
+  [
+    'https://api.example.com',
+    '/users/{id}',
+    { id: '123' },
+    'https://api.example.com/users/123',
+  ],
+  [
+    'https://api.example.com',
+    '/users/{userId}/posts/{postId}',
+    { userId: '123', postId: '456' },
+    'https://api.example.com/users/123/posts/456',
+  ],
+  [
+    'https://api.example.com',
+    '/users/{id}',
+    { id: '123', name: 'test' },
+    'https://api.example.com/users/123',
+  ],
+  [
+    'https://api.example.com',
+    '/users',
+    { id: '123' },
+    'https://api.example.com/users',
+  ],
+  [
+    'http://localhost:3000',
+    '/api/v1/users/{id}',
+    { id: '999' },
+    'http://localhost:3000/api/v1/users/999',
+  ],
+  [
+    'https://api.example.com',
+    '/users/{id}/profile',
+    { id: '123' },
+    'https://api.example.com/users/123/profile',
+  ],
+])('getApiEndpoint: baseUrl=%s, path=%s, params=%s -> %s', (baseUrl, path, params, expected) => {
+  expect(getApiEndpoint(baseUrl, path, params)).toBe(expected)
+})

package/src/api.ts

@@ -0,0 +1,303 @@
+import type {
+  Additional,
+  DevupApiRequestInit,
+  DevupApiStruct,
+  DevupApiStructKey,
+  DevupDeleteApiStruct,
+  DevupDeleteApiStructKey,
+  DevupGetApiStruct,
+  DevupGetApiStructKey,
+  DevupPatchApiStruct,
+  DevupPatchApiStructKey,
+  DevupPostApiStruct,
+  DevupPostApiStructKey,
+  DevupPutApiStruct,
+  DevupPutApiStructKey,
+  ExtractValue,
+  RequiredOptions,
+} from '@devup-api/core'
+import { convertResponse } from './response-converter'
+import { getUrlWithMethod } from './url-map'
+import { getApiEndpoint, isPlainObject } from './utils'
+
+type DevupApiResponse<T, E = unknown> =
+  | {
+      data: T
+      error?: undefined
+      response: Response
+    }
+  | {
+      data?: undefined
+      error: E
+      response: Response
+    }
+
+export class DevupApi {
+  private baseUrl: string
+  private defaultOptions: DevupApiRequestInit
+
+  constructor(baseUrl: string, defaultOptions: DevupApiRequestInit = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, '')
+    this.defaultOptions = defaultOptions
+  }
+
+  get<
+    T extends DevupGetApiStructKey,
+    O extends Additional<T, DevupGetApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response' | 'error'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'GET',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  GET<
+    T extends DevupGetApiStructKey,
+    O extends Additional<T, DevupGetApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'GET',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  post<
+    T extends DevupPostApiStructKey,
+    O extends Additional<T, DevupPostApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'POST',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  POST<
+    T extends DevupPostApiStructKey,
+    O extends Additional<T, DevupPostApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'POST',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  put<
+    T extends DevupPutApiStructKey,
+    O extends Additional<T, DevupPutApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'PUT',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  PUT<
+    T extends DevupPutApiStructKey,
+    O extends Additional<T, DevupPutApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'PUT',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  delete<
+    T extends DevupDeleteApiStructKey,
+    O extends Additional<T, DevupDeleteApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'DELETE',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  DELETE<
+    T extends DevupDeleteApiStructKey,
+    O extends Additional<T, DevupDeleteApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'DELETE',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  patch<
+    T extends DevupPatchApiStructKey,
+    O extends Additional<T, DevupPatchApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'PATCH',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  PATCH<
+    T extends DevupPatchApiStructKey,
+    O extends Additional<T, DevupPatchApiStruct>,
+  >(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    return this.request(path, {
+      method: 'PATCH',
+      ...options[0],
+    } as DevupApiRequestInit & Omit<O, 'response'>)
+  }
+
+  request<T extends DevupApiStructKey, O extends Additional<T, DevupApiStruct>>(
+    path: T,
+    ...options: [RequiredOptions<O>] extends [never]
+      ? [options?: DevupApiRequestInit]
+      : [options: DevupApiRequestInit & Omit<O, 'response'>]
+  ): Promise<
+    DevupApiResponse<
+      ExtractValue<O, 'response'>,
+      ExtractValue<O, 'error', unknown>
+    >
+  > {
+    const { method, url } = getUrlWithMethod(path)
+    const mergedOptions = {
+      ...this.defaultOptions,
+      ...options[0],
+    }
+    const requestOptions = {
+      ...mergedOptions,
+      method: mergedOptions.method || method,
+    }
+    if (requestOptions.body && isPlainObject(requestOptions.body)) {
+      requestOptions.body = JSON.stringify(requestOptions.body)
+    }
+    const request = new Request(
+      getApiEndpoint(
+        this.baseUrl,
+        url,
+        (
+          requestOptions as {
+            params?: Record<
+              string,
+              string | number | boolean | null | undefined
+            >
+          }
+        ).params,
+      ),
+      requestOptions as RequestInit,
+    )
+    return fetch(request).then((response) =>
+      convertResponse(request, response),
+    ) as Promise<
+      DevupApiResponse<
+        ExtractValue<O, 'response'>,
+        ExtractValue<O, 'error', unknown>
+      >
+    >
+  }
+
+  setDefaultOptions(options: DevupApiRequestInit) {
+    this.defaultOptions = options
+  }
+
+  getBaseUrl() {
+    return this.baseUrl
+  }
+
+  getDefaultOptions() {
+    return this.defaultOptions
+  }
+}

package/src/create-api.ts

@@ -0,0 +1,8 @@
+import { DevupApi } from './api'
+
+export function createApi(
+  baseUrl: string,
+  defaultOptions?: RequestInit,
+): DevupApi {
+  return new DevupApi(baseUrl, defaultOptions)
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from '@devup-api/core'
+export { createApi } from './create-api'

package/src/response-converter.ts

@@ -0,0 +1,44 @@
+/**
+ * OPENAPI-TYPESCRIPT
+ * @param request
+ * @param response
+ * @param parseAs
+ * @returns
+ */
+export async function convertResponse(
+  request: Request,
+  response: Response,
+  parseAs: 'stream' | 'json' | 'text' = 'json',
+): Promise<{
+  data?: unknown | undefined
+  error?: unknown | undefined
+  response: Response
+}> {
+  if (
+    response.status === 204 ||
+    request.method === 'HEAD' ||
+    response.headers.get('Content-Length') === '0'
+  ) {
+    return response.ok
+      ? { data: undefined, response }
+      : { error: undefined, response }
+  }
+
+  // parse response (falling back to .text() when necessary)
+  if (response.ok) {
+    // if "stream", skip parsing entirely
+    if (parseAs === 'stream') {
+      return { data: response.body, response }
+    }
+    return { data: await response[parseAs](), response }
+  }
+
+  // handle errors
+  let error = await response.text()
+  try {
+    error = JSON.parse(error) // attempt to parse as JSON
+  } catch {
+    // noop
+  }
+  return { error, response }
+}

package/src/url-map.ts

@@ -0,0 +1,13 @@
+import type { UrlMapValue } from '@devup-api/core'
+
+export const DEVUP_API_URL_MAP: Record<string, UrlMapValue> = JSON.parse(
+  process.env.DEVUP_API_URL_MAP || '{}',
+)
+
+export function getUrl(key: string): string {
+  return DEVUP_API_URL_MAP[key]?.url || key
+}
+
+export function getUrlWithMethod(key: string): UrlMapValue {
+  return DEVUP_API_URL_MAP[key] || { method: 'GET', url: key }
+}

package/src/utils.ts

@@ -0,0 +1,18 @@
+export function isPlainObject(obj: unknown): obj is object {
+  if (obj === null || typeof obj !== 'object') return false
+
+  const proto = Object.getPrototypeOf(obj)
+  return proto === Object.prototype
+}
+
+export function getApiEndpoint(
+  baseUrl: string,
+  path: string,
+  params?: object,
+): string {
+  let ret = `${baseUrl}${path}`
+  for (const [key, value] of Object.entries(params ?? {})) {
+    ret = ret.replace(`{${key}}`, value)
+  }
+  return ret
+}