@devup-api/generator 0.1.0

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

@@ -0,0 +1,318 @@
+import { expect, test } from 'bun:test'
+import type { UrlMapValue } from '@devup-api/core'
+import type { OpenAPIV3_1 } from 'openapi-types'
+import { createUrlMap } from '../create-url-map'
+
+test.each([
+  [
+    'camel',
+    undefined,
+    'get_users',
+    {
+      getUsers: { method: 'GET', url: '/users' },
+      '/users': { method: 'GET', url: '/users' },
+    },
+  ],
+  [
+    'snake',
+    { convertCase: 'snake' as const },
+    'getUsers',
+    {
+      get_users: { method: 'GET', url: '/users' },
+      '/users': { method: 'GET', url: '/users' },
+    },
+  ],
+  [
+    'pascal',
+    { convertCase: 'pascal' as const },
+    'get_users',
+    {
+      GetUsers: { method: 'GET', url: '/users' },
+      '/users': { method: 'GET', url: '/users' },
+    },
+  ],
+  [
+    'maintain',
+    { convertCase: 'maintain' as const },
+    'get_users',
+    {
+      get_users: { method: 'GET', url: '/users' },
+      '/users': { method: 'GET', url: '/users' },
+    },
+  ],
+])('creates url map with %s case conversion', (_, options, operationId, expected) => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        get: {
+          operationId,
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema, options)
+
+  expect(result).toEqual(expected as Record<string, UrlMapValue>)
+})
+
+test('converts path parameters based on convertCase', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users/{user_id}/posts/{post_id}': {
+        get: {
+          operationId: 'get_user_post',
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema, { convertCase: 'camel' })
+
+  expect(result).toEqual({
+    getUserPost: {
+      method: 'GET',
+      url: '/users/{userId}/posts/{postId}',
+    },
+    '/users/{userId}/posts/{postId}': {
+      method: 'GET',
+      url: '/users/{userId}/posts/{postId}',
+    },
+  })
+})
+
+test.each([
+  ['get', 'get_users', 'getUsers', 'GET'],
+  ['post', 'create_user', 'createUser', 'POST'],
+  ['put', 'update_user', 'updateUser', 'PUT'],
+  ['delete', 'delete_user', 'deleteUser', 'DELETE'],
+  ['patch', 'patch_user', 'patchUser', 'PATCH'],
+])('handles %s HTTP method', (method, operationId, expectedKey, expectedMethod) => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        [method]: {
+          operationId,
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toHaveProperty(expectedKey)
+  expect(result[expectedKey]?.method).toBe(
+    expectedMethod as 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
+  )
+  expect(result).toHaveProperty('/users')
+  expect(result['/users']?.method).toBe(
+    expectedMethod as 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
+  )
+})
+
+test('handles operation without operationId', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        get: {
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toEqual({
+    '/users': {
+      method: 'GET',
+      url: '/users',
+    },
+  })
+  expect(result).not.toHaveProperty('getUsers')
+})
+
+test('handles multiple paths', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        get: {
+          operationId: 'get_users',
+          responses: {},
+        },
+      },
+      '/posts': {
+        get: {
+          operationId: 'get_posts',
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toHaveProperty('getUsers')
+  expect(result).toHaveProperty('getPosts')
+  expect(result).toHaveProperty('/users')
+  expect(result).toHaveProperty('/posts')
+})
+
+test('handles empty paths', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {},
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toEqual({})
+})
+
+test('handles undefined paths', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    components: {},
+    paths: {},
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toEqual({})
+})
+
+test('handles undefined pathItem', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': undefined,
+    },
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toEqual({})
+})
+
+test('skips operations that do not exist', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        get: {
+          operationId: 'get_users',
+          responses: {},
+        },
+        // post, put, delete, patch are not defined
+      },
+    },
+  }
+
+  const result = createUrlMap(schema)
+
+  expect(result).toEqual({
+    getUsers: {
+      method: 'GET',
+      url: '/users',
+    },
+    '/users': {
+      method: 'GET',
+      url: '/users',
+    },
+  })
+})
+
+test('handles complex path with multiple parameters', () => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/api/v1/users/{user_id}/posts/{post_id}/comments/{comment_id}': {
+        get: {
+          operationId: 'get_user_post_comment',
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema, { convertCase: 'snake' })
+
+  expect(result).toEqual({
+    get_user_post_comment: {
+      method: 'GET',
+      url: '/api/v1/users/{user_id}/posts/{post_id}/comments/{comment_id}',
+    },
+    '/api/v1/users/{user_id}/posts/{post_id}/comments/{comment_id}': {
+      method: 'GET',
+      url: '/api/v1/users/{user_id}/posts/{post_id}/comments/{comment_id}',
+    },
+  })
+})
+
+test.each([
+  ['camel', '/users/{userId}', '/users/{userId}'],
+  ['snake', '/users/{user_id}', '/users/{user_id}'],
+  ['pascal', '/users/{UserId}', '/users/{UserId}'],
+])('converts path parameters with %s case: %s', (caseType, expectedPath, expectedUrl) => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users/{user_id}': {
+        get: {
+          operationId: 'get_user',
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema, {
+    convertCase: caseType as 'camel' | 'snake' | 'pascal',
+  })
+
+  expect(result[expectedPath]?.url).toBe(expectedUrl)
+})
+
+test.each([
+  ['camel', 'getUserList'],
+  ['snake', 'get_user_list'],
+  ['pascal', 'GetUserList'],
+])('converts operationId with %s case: %s', (caseType, expectedKey) => {
+  const schema: OpenAPIV3_1.Document = {
+    openapi: '3.1.0',
+    info: { title: 'Test API', version: '1.0.0' },
+    paths: {
+      '/users': {
+        get: {
+          operationId: 'get_user_list',
+          responses: {},
+        },
+      },
+    },
+  }
+
+  const result = createUrlMap(schema, {
+    convertCase: caseType as 'camel' | 'snake' | 'pascal',
+  })
+
+  expect(result).toHaveProperty(expectedKey)
+})

package/src/__tests__/index.test.ts

@@ -0,0 +1,9 @@
+import { expect, test } from 'bun:test'
+import * as indexModule from '../index'
+
+test('index.ts exports', () => {
+  expect({ ...indexModule }).toEqual({
+    createUrlMap: expect.any(Function),
+    generateInterface: expect.any(Function),
+  })
+})

package/src/__tests__/wrap-interface-key-guard.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from 'bun:test'
+import { wrapInterfaceKeyGuard } from '../wrap-interface-key-guard'
+
+test.each([
+  ['getUsers', 'getUsers'],
+  ['createUser', 'createUser'],
+  ['updateUser', 'updateUser'],
+  ['deleteUser', 'deleteUser'],
+  ['testKey', 'testKey'],
+  ['camelCase', 'camelCase'],
+  ['snake_case', 'snake_case'],
+  ['PascalCase', 'PascalCase'],
+] as const)('wrapInterfaceKeyGuard returns key as-is when no slash: %s -> %s', (key, expected) => {
+  expect(wrapInterfaceKeyGuard(key)).toBe(expected)
+})
+
+test.each([
+  ['/users', '[`/users`]'],
+  ['/users/{id}', '[`/users/{id}`]'],
+  ['/api/v1/users', '[`/api/v1/users`]'],
+  ['/users/{userId}/posts/{postId}', '[`/users/{userId}/posts/{postId}`]'],
+  ['/api/v1/users/{id}/profile', '[`/api/v1/users/{id}/profile`]'],
+] as const)('wrapInterfaceKeyGuard wraps key with backticks when slash present: %s -> %s', (key, expected) => {
+  expect(wrapInterfaceKeyGuard(key)).toBe(expected)
+})
+
+test.each([
+  ['', ''],
+  ['/', '[`/`]'],
+  ['//', '[`//`]'],
+  ['///', '[`///`]'],
+] as const)('wrapInterfaceKeyGuard handles edge cases: %s -> %s', (key, expected) => {
+  expect(wrapInterfaceKeyGuard(key)).toBe(expected)
+})
+
+test.each([
+  ['users/123', '[`users/123`]'],
+  ['test/path/here', '[`test/path/here`]'],
+  ['a/b/c/d', '[`a/b/c/d`]'],
+] as const)('wrapInterfaceKeyGuard wraps key with multiple slashes: %s -> %s', (key, expected) => {
+  expect(wrapInterfaceKeyGuard(key)).toBe(expected)
+})

package/src/convert-case.ts

@@ -0,0 +1,22 @@
+import { toCamel, toPascal, toSnake } from '@devup-api/utils'
+
+/**
+ * Convert string based on convertCase option
+ */
+export function convertCase(
+  str: string,
+  caseType: 'snake' | 'camel' | 'pascal' | 'maintain' = 'camel',
+): string {
+  switch (caseType) {
+    case 'snake':
+      return toSnake(str)
+    case 'camel':
+      return toCamel(str)
+    case 'pascal':
+      return toPascal(str)
+    case 'maintain':
+      return str
+    default:
+      return str
+  }
+}

package/src/create-url-map.ts

@@ -0,0 +1,43 @@
+import type { DevupApiTypeGeneratorOptions, UrlMapValue } from '@devup-api/core'
+import type { OpenAPIV3_1 } from 'openapi-types'
+import { convertCase } from './convert-case'
+
+export function createUrlMap(
+  schema: OpenAPIV3_1.Document,
+  options?: DevupApiTypeGeneratorOptions,
+) {
+  const convertCaseType = options?.convertCase ?? 'camel'
+  const urlMap: Record<string, UrlMapValue> = {}
+  for (const [path, pathItem] of Object.entries(schema.paths ?? {})) {
+    if (!pathItem) continue
+    for (const method of ['get', 'post', 'put', 'delete', 'patch'] as const) {
+      const operation = pathItem[method]
+      if (!operation) continue
+      const normalizedPath = path.replace(/\{([^}]+)\}/g, (_, param) => {
+        // Convert param name based on case type
+        return `{${convertCase(param, convertCaseType)}}`
+      })
+      if (operation.operationId) {
+        urlMap[convertCase(operation.operationId, convertCaseType)] = {
+          method: method.toUpperCase() as
+            | 'GET'
+            | 'POST'
+            | 'PUT'
+            | 'DELETE'
+            | 'PATCH',
+          url: normalizedPath,
+        }
+      }
+      urlMap[normalizedPath] = {
+        method: method.toUpperCase() as
+          | 'GET'
+          | 'POST'
+          | 'PUT'
+          | 'DELETE'
+          | 'PATCH',
+        url: normalizedPath,
+      }
+    }
+  }
+  return urlMap
+}