@kurly-growth/growthman 0.1.1 → 0.1.2

package/lib/openapi-parser.ts

@@ -1,270 +0,0 @@
-interface OpenAPISpec {
-  paths?: Record<string, Record<string, OpenAPIOperation>>
-  components?: {
-    schemas?: Record<string, OpenAPISchema>
-  }
-}
-
-interface OpenAPIOperation {
-  summary?: string
-  description?: string
-  responses?: Record<string, OpenAPIResponse>
-  requestBody?: {
-    content?: Record<string, { schema?: OpenAPISchema; example?: unknown }>
-  }
-}
-
-interface OpenAPIResponse {
-  description?: string
-  content?: Record<string, { schema?: OpenAPISchema; example?: unknown }>
-}
-
-interface OpenAPISchema {
-  type?: string
-  format?: string
-  properties?: Record<string, OpenAPISchema>
-  items?: OpenAPISchema
-  example?: unknown
-  default?: unknown
-  enum?: unknown[]
-  $ref?: string
-  allOf?: OpenAPISchema[]
-  oneOf?: OpenAPISchema[]
-  anyOf?: OpenAPISchema[]
-  nullable?: boolean
-  required?: string[]
-  additionalProperties?: boolean | OpenAPISchema
-}
-
-export interface ParsedEndpoint {
-  path: string
-  method: string
-  description: string | null
-  statusCode: number
-  responseBody: unknown
-}
-
-function resolveRef(ref: string, spec: OpenAPISpec): OpenAPISchema | null {
-  // $ref format: "#/components/schemas/SchemaName"
-  const parts = ref.split('/')
-  if (parts[0] !== '#' || parts[1] !== 'components' || parts[2] !== 'schemas') {
-    return null
-  }
-  const schemaName = parts[3]
-  return spec.components?.schemas?.[schemaName] || null
-}
-
-function generateMockValue(
-  schema: OpenAPISchema,
-  spec: OpenAPISpec,
-  visited: Set<string> = new Set()
-): unknown {
-  // Handle $ref
-  if (schema.$ref) {
-    // Prevent circular references
-    if (visited.has(schema.$ref)) {
-      return {}
-    }
-    visited.add(schema.$ref)
-    const resolved = resolveRef(schema.$ref, spec)
-    if (resolved) {
-      return generateMockValue(resolved, spec, visited)
-    }
-    return {}
-  }
-
-  // Handle allOf (merge schemas)
-  if (schema.allOf && schema.allOf.length > 0) {
-    const merged: Record<string, unknown> = {}
-    for (const subSchema of schema.allOf) {
-      const value = generateMockValue(subSchema, spec, visited)
-      if (typeof value === 'object' && value !== null) {
-        Object.assign(merged, value)
-      }
-    }
-    return merged
-  }
-
-  // Handle oneOf/anyOf (use first option)
-  if (schema.oneOf && schema.oneOf.length > 0) {
-    return generateMockValue(schema.oneOf[0], spec, visited)
-  }
-  if (schema.anyOf && schema.anyOf.length > 0) {
-    return generateMockValue(schema.anyOf[0], spec, visited)
-  }
-
-  // Use example or default if available
-  if (schema.example !== undefined) return schema.example
-  if (schema.default !== undefined) return schema.default
-  if (schema.enum && schema.enum.length > 0) return schema.enum[0]
-
-  // Generate based on type and format
-  switch (schema.type) {
-    case 'string':
-      return generateStringValue(schema.format)
-    case 'number':
-      return generateNumberValue(schema.format)
-    case 'integer':
-      return generateIntegerValue(schema.format)
-    case 'boolean':
-      return true
-    case 'array':
-      if (schema.items) {
-        return [generateMockValue(schema.items, spec, visited)]
-      }
-      return []
-    case 'object':
-      return generateObjectValue(schema, spec, visited)
-    default:
-      // If no type but has properties, treat as object
-      if (schema.properties) {
-        return generateObjectValue(schema, spec, visited)
-      }
-      return null
-  }
-}
-
-function generateStringValue(format?: string): string {
-  switch (format) {
-    case 'date':
-      return '2024-01-15'
-    case 'date-time':
-      return '2024-01-15T09:30:00Z'
-    case 'time':
-      return '09:30:00'
-    case 'email':
-      return 'user@example.com'
-    case 'uri':
-    case 'url':
-      return 'https://example.com'
-    case 'uuid':
-      return '550e8400-e29b-41d4-a716-446655440000'
-    case 'hostname':
-      return 'example.com'
-    case 'ipv4':
-      return '192.168.1.1'
-    case 'ipv6':
-      return '2001:0db8:85a3:0000:0000:8a2e:0370:7334'
-    case 'byte':
-      return 'SGVsbG8gV29ybGQ='
-    case 'binary':
-      return '<binary>'
-    case 'password':
-      return '********'
-    case 'phone':
-      return '+1-555-555-5555'
-    default:
-      return 'string'
-  }
-}
-
-function generateNumberValue(format?: string): number {
-  switch (format) {
-    case 'float':
-      return 1.5
-    case 'double':
-      return 1.23456789
-    default:
-      return 0
-  }
-}
-
-function generateIntegerValue(format?: string): number {
-  switch (format) {
-    case 'int32':
-      return 123
-    case 'int64':
-      return 1234567890
-    default:
-      return 0
-  }
-}
-
-function generateObjectValue(
-  schema: OpenAPISchema,
-  spec: OpenAPISpec,
-  visited: Set<string>
-): Record<string, unknown> {
-  const obj: Record<string, unknown> = {}
-
-  if (schema.properties) {
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      obj[key] = generateMockValue(propSchema, spec, visited)
-    }
-  }
-
-  return obj
-}
-
-export function parseOpenAPISpec(spec: OpenAPISpec): ParsedEndpoint[] {
-  const endpoints: ParsedEndpoint[] = []
-
-  if (!spec.paths) return endpoints
-
-  for (const [path, methods] of Object.entries(spec.paths)) {
-    for (const [method, operation] of Object.entries(methods)) {
-      // Skip non-HTTP method properties like 'parameters'
-      if (
-        !['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(
-          method.toLowerCase()
-        )
-      ) {
-        continue
-      }
-
-      const description = operation.summary || operation.description || null
-
-      // Find successful response (2xx)
-      let statusCode = 200
-      let responseBody: unknown = {}
-
-      if (operation.responses) {
-        // Sort response codes to prefer 200, then other 2xx
-        const responseCodes = Object.keys(operation.responses).sort((a, b) => {
-          if (a === '200') return -1
-          if (b === '200') return 1
-          return parseInt(a, 10) - parseInt(b, 10)
-        })
-
-        for (const code of responseCodes) {
-          const codeNum = parseInt(code, 10)
-          if (codeNum >= 200 && codeNum < 300) {
-            statusCode = codeNum
-            const response = operation.responses[code]
-
-            if (response.content) {
-              // Try application/json first, then any JSON-like content type
-              const jsonContent =
-                response.content['application/json'] ||
-                response.content['application/hal+json'] ||
-                response.content['application/vnd.api+json'] ||
-                Object.values(response.content).find((c) => c.schema)
-
-              if (jsonContent) {
-                if (jsonContent.example) {
-                  responseBody = jsonContent.example
-                } else if (jsonContent.schema) {
-                  responseBody = generateMockValue(jsonContent.schema, spec)
-                }
-              }
-            }
-            break
-          }
-        }
-      }
-
-      // Convert OpenAPI path params {id} to Express-style :id
-      const normalizedPath = path.replace(/\{(\w+)\}/g, ':$1')
-
-      endpoints.push({
-        path: normalizedPath,
-        method: method.toUpperCase(),
-        description,
-        statusCode,
-        responseBody,
-      })
-    }
-  }
-
-  return endpoints
-}

package/lib/prisma.ts

@@ -1,9 +0,0 @@
-import { PrismaClient } from '@prisma/client'
-
-const globalForPrisma = globalThis as unknown as {
-  prisma: PrismaClient | undefined
-}
-
-export const prisma = globalForPrisma.prisma ?? new PrismaClient()
-
-if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma

package/lib/utils.ts

@@ -1,6 +0,0 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}

package/lib/validation.ts

@@ -1,19 +0,0 @@
-const VALID_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
-
-export function validatePath(path: unknown): path is string {
-  if (!path || typeof path !== 'string') return false
-  if (!path.startsWith('/')) return false
-  if (path.length > 1000) return false
-  return true
-}
-
-export function validateMethod(method: unknown): method is string {
-  if (typeof method !== 'string') return false
-  return VALID_METHODS.includes(method.toUpperCase())
-}
-
-export function validateStatusCode(statusCode: unknown): statusCode is number {
-  if (statusCode === undefined || statusCode === null) return true // optional
-  if (typeof statusCode !== 'number') return false
-  return statusCode >= 100 && statusCode < 600
-}

package/next.config.ts

@@ -1,7 +0,0 @@
-import type { NextConfig } from "next";
-
-const nextConfig: NextConfig = {
-  /* config options here */
-};
-
-export default nextConfig;

package/prisma/seed.ts

@@ -1,29 +0,0 @@
-import { PrismaClient } from '@prisma/client'
-
-const prisma = new PrismaClient()
-
-async function main() {
-  // 기존 데이터 삭제
-  await prisma.mockEndpoint.deleteMany()
-  console.log('Cleared all mock endpoints')
-
-  // 샘플 데이터 추가 (선택사항)
-  // await prisma.mockEndpoint.create({
-  //   data: {
-  //     path: '/v1/health',
-  //     method: 'GET',
-  //     description: 'Health check',
-  //     statusCode: 200,
-  //     responseBody: { status: 'ok' },
-  //   },
-  // })
-}
-
-main()
-  .catch((e) => {
-    console.error(e)
-    process.exit(1)
-  })
-  .finally(async () => {
-    await prisma.$disconnect()
-  })

package/tsconfig.json

@@ -1,34 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2017",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "react-jsx",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "paths": {
-      "@/*": ["./*"]
-    }
-  },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts",
-    "**/*.mts"
-  ],
-  "exclude": ["node_modules"]
-}

package/types/endpoint.ts

@@ -1,10 +0,0 @@
-export interface MockEndpoint {
-  id: string
-  path: string
-  method: string
-  description: string | null
-  statusCode: number
-  responseBody: unknown
-  createdAt: string
-  updatedAt: string
-}