feat: Add Java code samples (#100)

* Add Java code samples

* ci: Generate code

* ci: Format code

* Format

* Fix req syntax

* ci: Generate code

* Improve readability and structure

* ci: Format code

---------

Co-authored-by: Seam Bot <devops@getseam.com>

src/lib/code-sample/java.ts

@@ -0,0 +1,77 @@
+import { camelCase, pascalCase } from 'change-case'
+
+import type { Json, NonNullJson } from 'lib/json.js'
+
+import { createJsonResponse } from './json.js'
+import type { CodeSampleDefinition, Context } from './schema.js'
+
+interface JavaRequestBuilderOptions {
+  path: string
+  parameters: NonNullJson
+}
+
+export const createJavaRequest = (
+  { request }: CodeSampleDefinition,
+  _context: Context,
+): string => {
+  const pathParts = request.path.split('/').slice(1)
+  const requestBuilderOptions: JavaRequestBuilderOptions = {
+    path: request.path,
+    parameters: request.parameters,
+  }
+  const clientArgs = createJavaRequestBuilder(requestBuilderOptions)
+
+  return `seam.${pathParts.map((p) => camelCase(p)).join('().')}(${clientArgs});`
+}
+
+const createJavaRequestBuilder = ({
+  path,
+  parameters,
+}: JavaRequestBuilderOptions): string => {
+  const requestBuilderName = getRequestBuilderName(path)
+  const isReqWithParams = Object.keys(parameters).length !== 0
+
+  if (!isReqWithParams) return ''
+
+  const formattedParams = formatJavaArgs(parameters)
+  return `${requestBuilderName}.builder()${formattedParams}.build()`
+}
+
+const getRequestBuilderName = (path: string): string => {
+  const requestBuilderNameSuffix = 'Request'
+  const pathParts = path.split('/').slice(1)
+
+  return isPathNested(pathParts)
+    ? `${pascalCase(pathParts.slice(1).join('_'))}${requestBuilderNameSuffix}`
+    : `${pascalCase(path)}${requestBuilderNameSuffix}`
+}
+
+const isPathNested = (pathParts: string[]): boolean => pathParts.length > 2
+
+const formatJavaArgs = (jsonParams: NonNullJson): string =>
+  Object.entries(jsonParams as Record<string, Json>)
+    .map(([paramKey, paramValue]) => {
+      const formattedValue = formatJavaValue(paramValue)
+      return `.${camelCase(paramKey)}(${formattedValue})`
+    })
+    .join('\n')
+
+const formatJavaValue = (value: Json): string => {
+  if (value === null) return 'null'
+  if (typeof value === 'boolean') return value.toString()
+  if (typeof value === 'number') return value.toString()
+  if (typeof value === 'string') return `"${value}"`
+  if (Array.isArray(value)) {
+    const formattedItems = value.map(formatJavaValue).join(', ')
+    return `List.of(${formattedItems})`
+  }
+  if (typeof value === 'object') {
+    const formattedEntries = Object.entries(value)
+      .map(([key, val]) => `"${key}", ${formatJavaValue(val)}`)
+      .join(', ')
+    return `Map.of(${formattedEntries})`
+  }
+  throw new Error(`Unsupported type: ${typeof value}`)
+}
+
+export const createJavaResponse = createJsonResponse

src/lib/code-sample/schema.ts

@@ -9,6 +9,7 @@ import { JsonSchema } from 'lib/json.js'
 
 import { formatCodeRecords } from './format.js'
 import { createGoRequest, createGoResponse } from './go.js'
+import { createJavaRequest, createJavaResponse } from './java.js'
 import {
   createJavascriptRequest,
   createJavascriptResponse,
@@ -49,12 +50,13 @@ const CodeSampleSyntaxSchema = z.enum([
   'ruby',
   'bash',
   'go',
+  'java',
 ])
 
 export type CodeSampleSyntax = z.infer<typeof CodeSampleSyntaxSchema>
 
 const CodeSchema = z.record(
-  z.enum(['javascript', 'python', 'php', 'ruby', 'seam_cli', 'go']),
+  z.enum(['javascript', 'python', 'php', 'ruby', 'seam_cli', 'go', 'java']),
   z.object({
     title: z.string().min(1),
     request: z.string(),
@@ -127,6 +129,13 @@ export const createCodeSample = async (
       request_syntax: 'go',
       response_syntax: 'json',
     },
+    java: {
+      title: 'Java',
+      request: createJavaRequest(codeSampleDefinition, context),
+      response: createJavaResponse(codeSampleDefinition, context),
+      request_syntax: 'java',
+      response_syntax: 'json',
+    },
   }
 
   return {