@devup-api/fetch 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@devup-api/fetch",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": {
@@ -9,6 +10,9 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc && bun build --target node --outfile=dist/index.js src/index.ts --production --packages=external && bun build --target node --outfile=dist/index.cjs --format=cjs src/index.ts --production --packages=external"
   },
@@ -16,7 +20,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@devup-api/core": "0.1.0"
+    "@devup-api/core": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^24.10",

package/dist/__tests__/api.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=api.test.d.ts.map

package/dist/__tests__/api.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/api.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/create-api.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=create-api.test.d.ts.map

package/dist/__tests__/create-api.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-api.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/create-api.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/__tests__/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/index.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/response-converter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=response-converter.test.d.ts.map

package/dist/__tests__/response-converter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"response-converter.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/response-converter.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/url-map.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=url-map.test.d.ts.map

package/dist/__tests__/url-map.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url-map.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/url-map.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/utils.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=utils.test.d.ts.map

package/dist/__tests__/utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/utils.test.ts"],"names":[],"mappings":""}

package/src/__tests__/api.test.ts

@@ -1,245 +0,0 @@
-import { afterEach, beforeEach, expect, mock, test } from 'bun:test'
-import { DevupApi } from '../api'
-
-const originalFetch = globalThis.fetch
-
-beforeEach(() => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(JSON.stringify({ success: true }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      }),
-    ),
-  ) as unknown as typeof fetch
-})
-
-afterEach(() => {
-  globalThis.fetch = originalFetch
-})
-
-test.each([
-  ['https://api.example.com', 'https://api.example.com'],
-  ['https://api.example.com/', 'https://api.example.com'],
-  ['http://localhost:3000', 'http://localhost:3000'],
-  ['http://localhost:3000/', 'http://localhost:3000'],
-] as const)('constructor removes trailing slash: %s -> %s', (baseUrl, expected) => {
-  const api = new DevupApi(baseUrl)
-  expect(api.getBaseUrl()).toBe(expected)
-})
-
-test.each([
-  [undefined, {}],
-  [{}, {}],
-  [
-    { headers: { Authorization: 'Bearer token' } },
-    { headers: { Authorization: 'Bearer token' } },
-  ],
-] as const)('constructor accepts defaultOptions: %s -> %s', (defaultOptions, expected) => {
-  const api = new DevupApi('https://api.example.com', defaultOptions)
-  expect(api.getDefaultOptions()).toEqual(expected)
-})
-
-test.each([
-  [{}, {}],
-  [
-    { headers: { 'Content-Type': 'application/json' } },
-    { headers: { 'Content-Type': 'application/json' } },
-  ],
-] as const)('setDefaultOptions updates defaultOptions: %s -> %s', (options, expected) => {
-  const api = new DevupApi('https://api.example.com')
-  api.setDefaultOptions(options)
-  expect(api.getDefaultOptions()).toEqual(expected)
-})
-
-test.each([
-  ['GET', 'get'],
-  ['GET', 'GET'],
-  ['POST', 'post'],
-  ['POST', 'POST'],
-  ['PUT', 'put'],
-  ['PUT', 'PUT'],
-  ['DELETE', 'delete'],
-  ['DELETE', 'DELETE'],
-  ['PATCH', 'patch'],
-  ['PATCH', 'PATCH'],
-] as const)('HTTP method %s calls request with correct method', async (expectedMethod, methodName) => {
-  const api = new DevupApi('https://api.example.com')
-  const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
-
-  await api[methodName]('/test' as never)
-
-  expect(mockFetch).toHaveBeenCalledTimes(1)
-  const call = mockFetch.mock.calls[0]
-  expect(call).toBeDefined()
-  if (call) {
-    const request = call[0] as Request
-    expect(request.method).toBe(expectedMethod)
-  }
-})
-
-test('request serializes plain object body to JSON', async () => {
-  const api = new DevupApi('https://api.example.com')
-  const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
-
-  await api.post(
-    '/test' as never,
-    {
-      body: { name: 'test', value: 123 },
-    } as never,
-  )
-
-  expect(mockFetch).toHaveBeenCalledTimes(1)
-  const call = mockFetch.mock.calls[0]
-  expect(call).toBeDefined()
-  if (call) {
-    const request = call[0] as Request
-    const body = await request.text()
-    expect(body).toBe(JSON.stringify({ name: 'test', value: 123 }))
-  }
-})
-
-test('request does not serialize non-plain object body', async () => {
-  const api = new DevupApi('https://api.example.com')
-  const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
-  const formData = new FormData()
-  formData.append('file', 'test')
-
-  await api.post(
-    '/test' as never,
-    {
-      body: formData,
-    } as never,
-  )
-
-  expect(mockFetch).toHaveBeenCalledTimes(1)
-  const call = mockFetch.mock.calls[0]
-  expect(call).toBeDefined()
-  if (call) {
-    const request = call[0] as Request
-    // FormData should not be serialized with JSON.stringify and should be passed as-is
-    // Request body should not be null
-    expect(request.body).not.toBeNull()
-    // FormData is automatically set to multipart/form-data
-    // body should exist
-    expect(request.body).toBeDefined()
-  }
-})
-
-test('request merges defaultOptions with request options', async () => {
-  const api = new DevupApi('https://api.example.com', {
-    headers: { 'X-Default': 'default-value' },
-  })
-  const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
-
-  await api.get(
-    '/test' as never,
-    {
-      headers: { 'X-Request': 'request-value' },
-    } as never,
-  )
-
-  expect(mockFetch).toHaveBeenCalledTimes(1)
-  const call = mockFetch.mock.calls[0]
-  expect(call).toBeDefined()
-  if (call) {
-    const request = call[0] as Request
-    // Headers are merged, but we can't easily test the merged result
-    // So we just verify the request was made
-    expect(request).toBeDefined()
-  }
-})
-
-test('request uses params to replace path parameters', async () => {
-  const api = new DevupApi('https://api.example.com')
-  const mockFetch = globalThis.fetch as unknown as ReturnType<typeof mock>
-
-  await api.get(
-    '/users/{id}' as never,
-    {
-      params: { id: '123' },
-    } as never,
-  )
-
-  expect(mockFetch).toHaveBeenCalledTimes(1)
-  const call = mockFetch.mock.calls[0]
-  expect(call).toBeDefined()
-  if (call) {
-    const request = call[0] as Request
-    expect(request.url).toBe('https://api.example.com/users/123')
-  }
-})
-
-test('request returns response with data on success', async () => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(JSON.stringify({ id: 1, name: 'test' }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      }),
-    ),
-  ) as unknown as typeof fetch
-
-  const api = new DevupApi('https://api.example.com')
-  const result = (await api.get('/test' as never)) as {
-    data?: unknown
-    error?: unknown
-    response: Response
-  }
-
-  expect('data' in result).toBe(true)
-  if ('data' in result && result.data !== undefined) {
-    expect(result.data).toEqual({ id: 1, name: 'test' })
-  }
-  expect('error' in result).toBe(false)
-  expect(result.response).toBeDefined()
-  expect(result.response.ok).toBe(true)
-})
-
-test('request returns response with error on failure', async () => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(JSON.stringify({ message: 'Not found' }), {
-        status: 404,
-        headers: { 'Content-Type': 'application/json' },
-      }),
-    ),
-  ) as unknown as typeof fetch
-
-  const api = new DevupApi('https://api.example.com')
-  const result = (await api.get('/test' as never)) as {
-    data?: unknown
-    error?: unknown
-    response: Response
-  }
-
-  expect('error' in result).toBe(true)
-  if ('error' in result && result.error !== undefined) {
-    expect(result.error).toEqual({ message: 'Not found' })
-  }
-  expect('data' in result).toBe(false)
-  expect(result.response).toBeDefined()
-  expect(result.response.ok).toBe(false)
-})
-
-test('request handles 204 No Content response', async () => {
-  globalThis.fetch = mock(() =>
-    Promise.resolve(
-      new Response(null, {
-        status: 204,
-      }),
-    ),
-  ) as unknown as typeof fetch
-
-  const api = new DevupApi('https://api.example.com')
-  const result = await api.delete('/test' as never)
-
-  if ('data' in result) {
-    expect(result.data).toBeUndefined()
-  }
-  if ('error' in result) {
-    expect(result.error).toBeUndefined()
-  }
-  expect(result.response).toBeDefined()
-  expect(result.response.status).toBe(204)
-})

package/src/__tests__/create-api.test.ts

@@ -1,25 +0,0 @@
-import { expect, test } from 'bun:test'
-import { DevupApi } from '../api'
-import { createApi } from '../create-api'
-
-test.each([
-  ['https://api.example.com'],
-  ['https://api.example.com/'],
-  ['http://localhost:3000'],
-  ['http://localhost:3000/'],
-] as const)('createApi returns DevupApi instance: %s', (baseUrl) => {
-  const api = createApi(baseUrl)
-  expect(api).toBeInstanceOf(DevupApi)
-})
-
-test.each([
-  ['https://api.example.com', undefined],
-  ['https://api.example.com', {}],
-  ['https://api.example.com', { headers: { Authorization: 'Bearer token' } }],
-] as const)('createApi accepts defaultOptions: %s', (baseUrl, defaultOptions) => {
-  const api = createApi(baseUrl, defaultOptions)
-  expect(api).toBeInstanceOf(DevupApi)
-  if (defaultOptions) {
-    expect(api.getDefaultOptions()).toEqual(defaultOptions)
-  }
-})

package/src/__tests__/index.test.ts

@@ -1,10 +0,0 @@
-import { expect, test } from 'bun:test'
-import * as indexModule from '../index'
-
-// Type imports to verify types are exported (compile-time check)
-
-test('index.ts exports', () => {
-  expect({ ...indexModule }).toEqual({
-    createApi: expect.any(Function),
-  })
-})

package/src/__tests__/response-converter.test.ts

@@ -1,158 +0,0 @@
-import { expect, test } from 'bun:test'
-import { convertResponse } from '../response-converter'
-
-test.each([
-  ['json', 'json'],
-  ['text', 'text'],
-  ['stream', 'stream'],
-] as const)('convertResponse parses successful response with parseAs=%s', async (parseAs) => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response(JSON.stringify({ id: 1, name: 'test' }), {
-    status: 200,
-    headers: { 'Content-Type': 'application/json' },
-  })
-
-  const result = await convertResponse(request, response, parseAs)
-
-  expect('data' in result).toBe(true)
-  if ('data' in result) {
-    if (parseAs === 'stream') {
-      expect(result.data).toBeDefined()
-    } else if (parseAs === 'text') {
-      expect(typeof result.data).toBe('string')
-    } else {
-      expect(result.data).toEqual({ id: 1, name: 'test' })
-    }
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles 204 No Content with success', async () => {
-  const request = new Request('https://api.example.com/test', {
-    method: 'DELETE',
-  })
-  const response = new Response(null, {
-    status: 204,
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('data' in result) {
-    expect(result.data).toBeUndefined()
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles 204 No Content with error', async () => {
-  const request = new Request('https://api.example.com/test', {
-    method: 'DELETE',
-  })
-  const response = new Response(null, {
-    status: 204,
-    statusText: 'No Content',
-  })
-
-  // Mock response.ok to be false
-  Object.defineProperty(response, 'ok', {
-    value: false,
-    writable: false,
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('error' in result) {
-    expect(result.error).toBeUndefined()
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles HEAD request', async () => {
-  const request = new Request('https://api.example.com/test', {
-    method: 'HEAD',
-  })
-  const response = new Response(null, {
-    status: 200,
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('data' in result) {
-    expect(result.data).toBeUndefined()
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles Content-Length: 0', async () => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response(null, {
-    status: 200,
-    headers: { 'Content-Length': '0' },
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('data' in result) {
-    expect(result.data).toBeUndefined()
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles error response with JSON', async () => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response(JSON.stringify({ message: 'Not found' }), {
-    status: 404,
-    headers: { 'Content-Type': 'application/json' },
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('error' in result) {
-    expect(result.error).toEqual({ message: 'Not found' })
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles error response with non-JSON text', async () => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response('Internal Server Error', {
-    status: 500,
-    headers: { 'Content-Type': 'text/plain' },
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('error' in result) {
-    expect(result.error).toBe('Internal Server Error')
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles error response with invalid JSON', async () => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response('Invalid JSON{', {
-    status: 400,
-    headers: { 'Content-Type': 'application/json' },
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('error' in result) {
-    expect(result.error).toBe('Invalid JSON{')
-  }
-  expect(result.response).toBe(response)
-})
-
-test('convertResponse handles non-204 error with Content-Length: 0', async () => {
-  const request = new Request('https://api.example.com/test', { method: 'GET' })
-  const response = new Response(null, {
-    status: 500,
-    headers: { 'Content-Length': '0' },
-  })
-
-  const result = await convertResponse(request, response)
-
-  if ('error' in result) {
-    expect(result.error).toBeUndefined()
-  }
-  expect(result.response).toBe(response)
-})

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

@@ -1,182 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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

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

package/src/index.ts

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

package/src/response-converter.ts

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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
-}

package/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "verbatimModuleSyntax": true,
-    "emitDeclarationOnly": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["dist", "node_modules"]
-}