@kurly-growth/growthman 0.1.14 → 0.1.15

package/app/api/endpoints/[id]/route.ts

@@ -0,0 +1,63 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/prisma'
+import { validatePath, validateMethod, validateStatusCode } from '@/lib/validation'
+
+type RouteParams = {
+  params: Promise<{ id: string }>
+}
+
+// GET: 단일 엔드포인트 조회
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  const { id } = await params
+
+  const endpoint = await prisma.mockEndpoint.findUnique({
+    where: { id },
+  })
+
+  if (!endpoint) {
+    return NextResponse.json({ error: 'Endpoint not found' }, { status: 404 })
+  }
+
+  return NextResponse.json(endpoint)
+}
+
+// PUT: 엔드포인트 수정
+export async function PUT(request: NextRequest, { params }: RouteParams) {
+  const { id } = await params
+  const body = await request.json()
+  const { path, method, description, statusCode, responseBody } = body
+
+  if (path !== undefined && !validatePath(path)) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+  }
+  if (method !== undefined && !validateMethod(method)) {
+    return NextResponse.json({ error: 'Invalid method' }, { status: 400 })
+  }
+  if (!validateStatusCode(statusCode)) {
+    return NextResponse.json({ error: 'Invalid status code' }, { status: 400 })
+  }
+
+  const endpoint = await prisma.mockEndpoint.update({
+    where: { id },
+    data: {
+      path,
+      method: method?.toUpperCase(),
+      description,
+      statusCode,
+      responseBody,
+    },
+  })
+
+  return NextResponse.json(endpoint)
+}
+
+// DELETE: 엔드포인트 삭제
+export async function DELETE(_request: NextRequest, { params }: RouteParams) {
+  const { id } = await params
+
+  await prisma.mockEndpoint.delete({
+    where: { id },
+  })
+
+  return NextResponse.json({ success: true })
+}

package/app/api/endpoints/bulk/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/prisma'
+
+// DELETE: 여러 엔드포인트 일괄 삭제
+export async function DELETE(request: NextRequest) {
+  const body = await request.json()
+  const { ids } = body
+
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return NextResponse.json(
+      { error: 'ids must be a non-empty array' },
+      { status: 400 }
+    )
+  }
+
+  const result = await prisma.mockEndpoint.deleteMany({
+    where: {
+      id: { in: ids },
+    },
+  })
+
+  return NextResponse.json({ deleted: result.count })
+}

package/app/api/endpoints/import/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { Prisma } from '@/generated/prisma'
+import { prisma } from '@/lib/prisma'
+import { parseOpenAPISpec } from '@/lib/openapi-parser'
+
+export async function POST(request: NextRequest) {
+  const body = await request.json()
+  const { spec, pathPrefix } = body
+
+  // Handle both old format (spec directly) and new format ({ spec, pathPrefix })
+  const actualSpec = spec ?? body
+  const endpoints = parseOpenAPISpec(actualSpec)
+
+  // Apply path prefix if provided
+  const normalizedPrefix = pathPrefix ? pathPrefix.replace(/\/+$/, '') : ''
+  const processedEndpoints = endpoints.map((ep) => ({
+    ...ep,
+    path: normalizedPrefix ? `${normalizedPrefix}${ep.path}` : ep.path,
+  }))
+
+  if (processedEndpoints.length === 0) {
+    return NextResponse.json(
+      { error: 'No valid endpoints found in OpenAPI spec' },
+      { status: 400 }
+    )
+  }
+
+  const results = await Promise.allSettled(
+    processedEndpoints.map((ep) =>
+      prisma.mockEndpoint.upsert({
+        where: {
+          path_method: {
+            path: ep.path,
+            method: ep.method,
+          },
+        },
+        update: {
+          description: ep.description,
+          statusCode: ep.statusCode,
+          responseBody: ep.responseBody as Prisma.InputJsonValue,
+        },
+        create: {
+          path: ep.path,
+          method: ep.method,
+          description: ep.description,
+          statusCode: ep.statusCode,
+          responseBody: ep.responseBody as Prisma.InputJsonValue,
+        },
+      })
+    )
+  )
+
+  const created = results.filter((r) => r.status === 'fulfilled').length
+  const failed = results.filter((r) => r.status === 'rejected').length
+
+  return NextResponse.json({
+    message: `Imported ${created} endpoints`,
+    created,
+    failed,
+    total: processedEndpoints.length,
+  })
+}

package/app/api/endpoints/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/prisma'
+import { validatePath, validateMethod, validateStatusCode } from '@/lib/validation'
+
+// GET: 모든 엔드포인트 조회
+export async function GET() {
+  const endpoints = await prisma.mockEndpoint.findMany({
+    orderBy: { createdAt: 'desc' },
+  })
+  return NextResponse.json(endpoints)
+}
+
+// POST: 새 엔드포인트 생성
+export async function POST(request: NextRequest) {
+  const body = await request.json()
+  const { path, method, description, statusCode, responseBody } = body
+
+  if (!validatePath(path)) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+  }
+  if (!validateMethod(method)) {
+    return NextResponse.json({ error: 'Invalid method' }, { status: 400 })
+  }
+  if (!validateStatusCode(statusCode)) {
+    return NextResponse.json({ error: 'Invalid status code' }, { status: 400 })
+  }
+
+  const endpoint = await prisma.mockEndpoint.create({
+    data: {
+      path,
+      method: method.toUpperCase(),
+      description,
+      statusCode: statusCode ?? 200,
+      responseBody,
+    },
+  })
+
+  return NextResponse.json(endpoint, { status: 201 })
+}

package/app/api/endpoints/sync/route.ts

@@ -0,0 +1,89 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { Prisma } from '@/generated/prisma'
+import { prisma } from '@/lib/prisma'
+import { parseOpenAPISpec } from '@/lib/openapi-parser'
+
+export async function POST(request: NextRequest) {
+  const { url, pathPrefix } = await request.json()
+
+  if (!url) {
+    return NextResponse.json({ error: 'URL is required' }, { status: 400 })
+  }
+
+  // Normalize path prefix (remove trailing slashes)
+  const normalizedPrefix = pathPrefix ? pathPrefix.replace(/\/+$/, '') : ''
+
+  try {
+    // OpenAPI JSON 가져오기
+    const response = await fetch(url, {
+      headers: {
+        Accept: 'application/json',
+      },
+    })
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: `Failed to fetch OpenAPI spec: ${response.statusText}` },
+        { status: 400 }
+      )
+    }
+
+    const spec = await response.json()
+    const endpoints = parseOpenAPISpec(spec)
+
+    // Apply path prefix if provided
+    const processedEndpoints = endpoints.map((ep) => ({
+      ...ep,
+      path: normalizedPrefix ? `${normalizedPrefix}${ep.path}` : ep.path,
+    }))
+
+    if (processedEndpoints.length === 0) {
+      return NextResponse.json(
+        { error: 'No valid endpoints found in OpenAPI spec' },
+        { status: 400 }
+      )
+    }
+
+    // Upsert로 새로 추가하거나 업데이트
+    const results = await Promise.allSettled(
+      processedEndpoints.map((ep) =>
+        prisma.mockEndpoint.upsert({
+          where: {
+            path_method: {
+              path: ep.path,
+              method: ep.method,
+            },
+          },
+          update: {
+            description: ep.description,
+            statusCode: ep.statusCode,
+            responseBody: ep.responseBody as Prisma.InputJsonValue,
+          },
+          create: {
+            path: ep.path,
+            method: ep.method,
+            description: ep.description,
+            statusCode: ep.statusCode,
+            responseBody: ep.responseBody as Prisma.InputJsonValue,
+          },
+        })
+      )
+    )
+
+    const succeeded = results.filter((r) => r.status === 'fulfilled').length
+    const failed = results.filter((r) => r.status === 'rejected').length
+
+    return NextResponse.json({
+      message: `Synced ${succeeded} endpoints`,
+      succeeded,
+      failed,
+      total: processedEndpoints.length,
+    })
+  } catch (error) {
+    console.error('Sync error:', error)
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Sync failed' },
+      { status: 500 }
+    )
+  }
+}

package/app/api/mock/[...slug]/route.ts

@@ -0,0 +1,82 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { match } from 'path-to-regexp'
+import { prisma } from '@/lib/prisma'
+
+type RouteParams = {
+  params: Promise<{ slug: string[] }>
+}
+
+async function findMatchingEndpoint(requestPath: string, method: string) {
+  // DB에서 해당 method의 모든 엔드포인트 조회
+  const endpoints = await prisma.mockEndpoint.findMany({
+    where: { method },
+  })
+
+  // 정확히 일치하는 경로 먼저 확인
+  const exactMatch = endpoints.find((ep) => ep.path === requestPath)
+  if (exactMatch) {
+    return { endpoint: exactMatch, params: {} }
+  }
+
+  // path-to-regexp를 사용한 패턴 매칭
+  for (const endpoint of endpoints) {
+    try {
+      const matchFn = match(endpoint.path, { decode: decodeURIComponent })
+      const result = matchFn(requestPath)
+
+      if (result) {
+        return { endpoint, params: result.params }
+      }
+    } catch {
+      // 잘못된 패턴은 무시
+      continue
+    }
+  }
+
+  return null
+}
+
+async function handleRequest(request: NextRequest, { params }: RouteParams) {
+  const { slug } = await params
+  const requestPath = '/' + slug.join('/')
+  const method = request.method
+
+  const result = await findMatchingEndpoint(requestPath, method)
+
+  if (!result) {
+    return NextResponse.json(
+      { error: 'Endpoint not found', path: requestPath, method },
+      { status: 404 }
+    )
+  }
+
+  const { endpoint, params: pathParams } = result
+
+  // responseBody에 pathParams를 포함하여 반환 (선택적)
+  const responseData =
+    Object.keys(pathParams).length > 0
+      ? { ...endpoint.responseBody as object, _pathParams: pathParams }
+      : endpoint.responseBody
+
+  return NextResponse.json(responseData, { status: endpoint.statusCode })
+}
+
+export async function GET(request: NextRequest, context: RouteParams) {
+  return handleRequest(request, context)
+}
+
+export async function POST(request: NextRequest, context: RouteParams) {
+  return handleRequest(request, context)
+}
+
+export async function PUT(request: NextRequest, context: RouteParams) {
+  return handleRequest(request, context)
+}
+
+export async function PATCH(request: NextRequest, context: RouteParams) {
+  return handleRequest(request, context)
+}
+
+export async function DELETE(request: NextRequest, context: RouteParams) {
+  return handleRequest(request, context)
+}

package/lib/openapi-parser.ts

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

@@ -0,0 +1,9 @@
+import { PrismaClient } from '@/generated/prisma'
+
+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

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

package/lib/validation.ts

@@ -0,0 +1,19 @@
+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-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/next.config.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kurly-growth/growthman",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Local mock API server with UI dashboard",
   "bin": {
     "growthman": "./bin/cli.js"

package/prisma/seed.ts

@@ -0,0 +1,29 @@
+import { PrismaClient } from '../generated/prisma'
+
+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

@@ -0,0 +1,34 @@
+{
+  "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

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