@devup-api/generator 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@devup-api/generator",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "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,8 +20,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@devup-api/core": "0.1.0",
-    "@devup-api/utils": "0.1.0"
+    "@devup-api/core": "0.1.1",
+    "@devup-api/utils": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^24.10",

package/src/__tests__/convert-case.test.ts

@@ -1,125 +0,0 @@
-import { expect, test } from 'bun:test'
-import { convertCase } from '../convert-case'
-
-test.each([
-  ['hello_world', 'snake', 'hello_world'],
-  ['my_variable_name', 'snake', 'my_variable_name'],
-  ['snake_case_string', 'snake', 'snake_case_string'],
-])('converts to snake_case: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'snake')).toBe(expected)
-})
-
-test.each([
-  ['HelloWorld', 'snake', 'hello_world'],
-  ['MyVariableName', 'snake', 'my_variable_name'],
-  ['PascalCaseString', 'snake', 'pascal_case_string'],
-])('converts PascalCase to snake_case: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'snake')).toBe(expected)
-})
-
-test.each([
-  ['helloWorld', 'snake', 'hello_world'],
-  ['myVariableName', 'snake', 'my_variable_name'],
-  ['camelCaseString', 'snake', 'camel_case_string'],
-])('converts camelCase to snake_case: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'snake')).toBe(expected)
-})
-
-test.each([
-  ['hello_world', 'camel', 'helloWorld'],
-  ['my_variable_name', 'camel', 'myVariableName'],
-  ['snake_case_string', 'camel', 'snakeCaseString'],
-])('converts to camelCase: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'camel')).toBe(expected)
-})
-
-test.each([
-  ['HelloWorld', 'camel', 'helloWorld'],
-  ['MyVariableName', 'camel', 'myVariableName'],
-  ['PascalCaseString', 'camel', 'pascalCaseString'],
-])('converts PascalCase to camelCase: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'camel')).toBe(expected)
-})
-
-test.each([
-  ['helloWorld', 'camel', 'helloWorld'],
-  ['myVariableName', 'camel', 'myVariableName'],
-  ['camelCaseString', 'camel', 'camelCaseString'],
-])('returns camelCase strings unchanged: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'camel')).toBe(expected)
-})
-
-test.each([
-  ['hello_world', 'pascal', 'HelloWorld'],
-  ['my_variable_name', 'pascal', 'MyVariableName'],
-  ['snake_case_string', 'pascal', 'SnakeCaseString'],
-])('converts to PascalCase: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'pascal')).toBe(expected)
-})
-
-test.each([
-  ['helloWorld', 'pascal', 'HelloWorld'],
-  ['myVariableName', 'pascal', 'MyVariableName'],
-  ['camelCaseString', 'pascal', 'CamelCaseString'],
-])('converts camelCase to PascalCase: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'pascal')).toBe(expected)
-})
-
-test.each([
-  ['HelloWorld', 'pascal', 'HelloWorld'],
-  ['MyVariableName', 'pascal', 'MyVariableName'],
-  ['PascalCaseString', 'pascal', 'PascalCaseString'],
-])('returns PascalCase strings unchanged: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'pascal')).toBe(expected)
-})
-
-test.each([
-  ['hello_world', 'maintain', 'hello_world'],
-  ['myVariableName', 'maintain', 'myVariableName'],
-  ['HelloWorld', 'maintain', 'HelloWorld'],
-  ['any_string-here', 'maintain', 'any_string-here'],
-])('maintains original case: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'maintain')).toBe(expected)
-})
-
-test.each([
-  ['hello_world', undefined, 'helloWorld'],
-  ['my_variable_name', undefined, 'myVariableName'],
-  ['snake_case_string', undefined, 'snakeCaseString'],
-])('defaults to camelCase when caseType is undefined: %s -> %s', (input, caseType, expected) => {
-  // biome-ignore lint/suspicious/noExplicitAny: Testing default behavior with undefined caseType
-  expect(convertCase(input, caseType as any)).toBe(expected)
-})
-
-test.each([
-  ['hello_world', 'helloWorld'],
-  ['my_variable_name', 'myVariableName'],
-  ['snake_case_string', 'snakeCaseString'],
-])('defaults to camelCase when caseType is not provided: %s -> %s', (input, expected) => {
-  expect(convertCase(input)).toBe(expected)
-})
-
-test.each([
-  ['', 'camel', ''],
-  ['a', 'camel', 'a'],
-  ['A', 'camel', 'a'],
-])('handles empty string and single characters: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'camel')).toBe(expected)
-})
-
-test.each([
-  ['hello_world123', 'camel', 'helloWorld123'],
-  ['my_variable2_name', 'camel', 'myVariable2Name'],
-  ['test123_case', 'camel', 'test123Case'],
-])('handles strings with numbers: %s -> %s', (input, caseType, expected) => {
-  expect(convertCase(input, caseType as 'camel')).toBe(expected)
-})
-
-test.each([
-  ['hello_world', 'invalid', 'hello_world'],
-  ['myVariableName', 'unknown', 'myVariableName'],
-  ['HelloWorld', 'wrong', 'HelloWorld'],
-])('default case returns original string for invalid caseType: %s -> %s', (input, caseType, expected) => {
-  // biome-ignore lint/suspicious/noExplicitAny: Testing default case with invalid caseType values
-  expect(convertCase(input, caseType as any)).toBe(expected)
-})

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

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

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

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

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

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