@carthooks/arcubase-cli 0.1.25 → 0.1.26

package/src/runtime/dev_sdk_gen.ts

@@ -1,20 +1,666 @@
-import {
-  ArcubaseCodeGenError,
-  generateArcubaseProjectSDK as generateArcubaseProjectSDKCore,
-  type GeneratedSDK,
-} from '@arcubase/code-gen'
-
 import { CLIError } from './errors.js'
 
-export type { GeneratedSDK, GeneratedSDKFile } from '@arcubase/code-gen'
+export type GeneratedSDKFile = {
+  path: string
+  contents: string
+}
 
-export function generateArcubaseProjectSDK(payload: unknown): GeneratedSDK {
-  try {
-    return generateArcubaseProjectSDKCore(payload)
-  } catch (error) {
-    if (error instanceof ArcubaseCodeGenError) {
-      throw new CLIError(error.code, error.message, 2)
+export type GeneratedSDK = {
+  files: GeneratedSDKFile[]
+}
+
+type ArcubaseField = {
+  id: number
+  label: string
+  key: string
+  type: string
+  required: boolean
+  options?: Record<string, unknown>
+  children?: ArcubaseField[]
+}
+
+type ArcubaseEntity = {
+  appId: number
+  id: number
+  name: string
+  fields: ArcubaseField[]
+}
+
+type ArcubaseIngress = {
+  appId: number
+  id?: number
+  hashId: string
+  key: string
+  name: string
+  actions: string[]
+  entity: ArcubaseEntity
+  listOptions?: Record<string, unknown>
+}
+
+const identifierPattern = /^[A-Za-z][A-Za-z0-9_]*$/
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function unwrapData(payload: unknown): unknown {
+  return isRecord(payload) && 'data' in payload ? payload.data : payload
+}
+
+function toPascalCase(value: string): string {
+  const words = value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+  if (words.length === 0) return 'Ingress'
+  return words.map((word) => `${word[0].toUpperCase()}${word.slice(1)}`).join('')
+}
+
+function normalizeFieldType(type: string): string {
+  switch (type) {
+    case 'number':
+      return 'number'
+    case 'boolean':
+      return 'boolean'
+    case 'select':
+    case 'radio':
+    case 'checkbox':
+    case 'status':
+      return 'number | string'
+    case 'file':
+    case 'image':
+    case 'member':
+    case 'members':
+    case 'department':
+    case 'departments':
+    case 'linkto':
+    case 'relation':
+    case 'relationfield':
+    case 'subform':
+      return 'unknown'
+    default:
+      return 'string'
+  }
+}
+
+function normalizeField(field: Record<string, unknown>): ArcubaseField | undefined {
+  if (typeof field.id !== 'number' || typeof field.label !== 'string' || typeof field.type !== 'string') {
+    return undefined
+  }
+  const children = Array.isArray(field.children)
+    ? field.children
+        .filter((child): child is Record<string, unknown> => isRecord(child))
+        .map(normalizeField)
+        .filter((child): child is ArcubaseField => Boolean(child))
+    : undefined
+  return {
+    id: field.id,
+    label: field.label,
+    key: typeof field.key === 'string' ? field.key.trim() : '',
+    type: field.type,
+    required: field.required === true,
+    options: isRecord(field.options) ? field.options : undefined,
+    children,
+  }
+}
+
+function normalizeEntity(payload: unknown, appId: number): ArcubaseEntity {
+  if (!isRecord(payload) || typeof payload.id !== 'number' || typeof payload.name !== 'string') {
+    throw new CLIError('SDK_GEN_INVALID_SCHEMA', 'sdk-gen expected ingress.entity with id and name', 2)
+  }
+  const fields = Array.isArray(payload.fields)
+    ? payload.fields
+        .filter((field): field is Record<string, unknown> => isRecord(field))
+        .map(normalizeField)
+        .filter((field): field is ArcubaseField => Boolean(field))
+    : []
+  return {
+    appId,
+    id: payload.id,
+    name: payload.name,
+    fields,
+  }
+}
+
+function normalizeActions(ingress: Record<string, any>): string[] {
+  const policy = isRecord(ingress.policy)
+    ? ingress.policy
+    : isRecord(ingress.options) && isRecord(ingress.options.policy)
+      ? ingress.options.policy
+      : undefined
+  const source = Array.isArray(ingress.actions) ? ingress.actions : Array.isArray(policy?.actions) ? policy.actions : []
+  return source.filter((action): action is string => typeof action === 'string' && action.trim() !== '').map((action) => action.trim())
+}
+
+function normalizeIngresses(payload: unknown): ArcubaseIngress[] {
+  const root = unwrapData(payload)
+  if (!isRecord(root)) {
+    throw new CLIError('SDK_GEN_INVALID_SCHEMA', 'sdk-gen expected an app ingress schema object', 2)
+  }
+  const appId = typeof root.id === 'number' ? root.id : typeof root.app_id === 'number' ? root.app_id : undefined
+  if (!appId) {
+    throw new CLIError('SDK_GEN_APP_ID_REQUIRED', 'sdk-gen expected app id in schema payload', 2)
+  }
+  const sourceIngresses = Array.isArray(root.ingresses) ? root.ingresses : []
+  if (sourceIngresses.length === 0) {
+    throw new CLIError('SDK_GEN_NO_INGRESSES', 'sdk-gen could not find ingresses in schema payload', 2)
+  }
+  const ingresses = sourceIngresses
+    .filter((item): item is Record<string, any> => isRecord(item))
+    .map((item) => {
+      const entity = normalizeEntity(item.entity, appId)
+      const options = isRecord(item.options) ? item.options : {}
+      const hashId = typeof item.hash_id === 'string'
+        ? item.hash_id.trim()
+        : typeof item.hashId === 'string'
+          ? item.hashId.trim()
+          : ''
+      return {
+        appId,
+        id: typeof item.id === 'number' ? item.id : undefined,
+        hashId,
+        key: typeof item.key === 'string' ? item.key.trim() : '',
+        name: typeof item.name === 'string' && item.name.trim() ? item.name.trim() : String(item.key ?? ''),
+        actions: normalizeActions(item),
+        entity,
+        listOptions: isRecord(options.list_options) ? options.list_options : isRecord(item.list_options) ? item.list_options : undefined,
+      }
+    })
+  validateIngresses(ingresses)
+  return ingresses
+}
+
+function walkFields(fields: ArcubaseField[], visit: (field: ArcubaseField) => void) {
+  for (const field of fields) {
+    visit(field)
+    if (field.children && field.children.length > 0) {
+      walkFields(field.children, visit)
+    }
+  }
+}
+
+function allFields(entity: ArcubaseEntity): ArcubaseField[] {
+  const out: ArcubaseField[] = []
+  walkFields(entity.fields, (field) => out.push(field))
+  return out
+}
+
+function validateIngresses(ingresses: ArcubaseIngress[]) {
+  const ingressKeys = new Set<string>()
+  for (const ingress of ingresses) {
+    if (!ingress.key) {
+      throw new CLIError('SDK_GEN_INGRESS_KEY_REQUIRED', `ingress.key is required for ${ingress.name || 'unnamed ingress'}`, 2)
+    }
+    if (!identifierPattern.test(ingress.key)) {
+      throw new CLIError('SDK_GEN_INVALID_INGRESS_KEY', `ingress.key must be a TypeScript identifier: ${ingress.key}`, 2)
+    }
+    if (ingressKeys.has(ingress.key)) {
+      throw new CLIError('SDK_GEN_DUPLICATE_INGRESS_KEY', `duplicate ingress.key: ${ingress.key}`, 2)
+    }
+    ingressKeys.add(ingress.key)
+    if (!ingress.hashId) {
+      throw new CLIError('SDK_GEN_INGRESS_HASH_ID_REQUIRED', `ingress.hash_id is required for ${ingress.key}`, 2)
+    }
+
+    const fieldKeys = new Set<string>()
+    for (const field of allFields(ingress.entity)) {
+      if (!field.key) {
+        throw new CLIError('SDK_GEN_FIELD_KEY_REQUIRED', `field.key is required for ${ingress.entity.name}.${field.label} (${field.id})`, 2)
+      }
+      if (!identifierPattern.test(field.key)) {
+        throw new CLIError('SDK_GEN_INVALID_FIELD_KEY', `field.key must be a TypeScript identifier: ${ingress.entity.name}.${field.key}`, 2)
+      }
+      if (fieldKeys.has(field.key)) {
+        throw new CLIError('SDK_GEN_DUPLICATE_FIELD_KEY', `duplicate field.key in ${ingress.entity.name}: ${field.key}`, 2)
+      }
+      fieldKeys.add(field.key)
+    }
+  }
+}
+
+function hasAction(ingress: ArcubaseIngress, action: string): boolean {
+  return ingress.actions.includes(action)
+}
+
+function methodLines(lines: string[]): string {
+  return lines.length > 0 ? `${lines.join('\n\n')}\n` : ''
+}
+
+function emitRuntime(): string {
+  return `export type ArcubaseClientConfig = {
+  baseURL: string
+  accessToken?: string
+  refreshToken?: string
+}
+
+export type ArcubaseRow<TFields> = {
+  id: number
+  title?: string
+  fields: TFields
+  raw: Record<string, any>
+}
+
+export type ArcubaseRuntime = {
+  request<T>(method: string, endpoint: string, body?: unknown): Promise<T>
+}
+
+type ArcubaseEnvelope<T> = {
+  data?: T
+  error?: { message?: string; key?: string; type?: string }
+}
+
+export function createRuntime(config: ArcubaseClientConfig): ArcubaseRuntime {
+  let accessToken = config.accessToken ?? ''
+  let refreshToken = config.refreshToken ?? ''
+
+  async function request<T>(method: string, endpoint: string, body?: unknown): Promise<T> {
+    const baseURL = config.baseURL.endsWith('/') ? config.baseURL : \`\${config.baseURL}/\`
+    const response = await fetch(new URL(endpoint.replace(/^\\/+/, ''), baseURL).toString(), {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(accessToken ? { Authorization: \`Bearer \${accessToken}\` } : {}),
+        ...(refreshToken ? { 'X-Arcubase-Refresh-Token': refreshToken } : {}),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    })
+    const payload = await response.json().catch(() => null) as ArcubaseEnvelope<T> | null
+    if (!response.ok || payload?.error) {
+      throw new Error(payload?.error?.message ?? \`Arcubase request failed: \${response.status}\`)
+    }
+    return payload?.data as T
+  }
+
+  return { request }
+}
+
+export function toArcubaseFields<T extends Record<string, any>>(fields: Partial<T>, fieldIds: Record<string, number>): Record<string, any> {
+  const out: Record<string, any> = {}
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined) continue
+    const fieldId = fieldIds[key]
+    if (!fieldId) {
+      throw new Error(\`Unknown Arcubase field: \${key}\`)
+    }
+    out[String(fieldId)] = value
+  }
+  return out
+}
+
+export function fromArcubaseFields<T>(raw: Record<string, any> | undefined, fieldIds: Record<string, number>): T {
+  const out: Record<string, any> = {}
+  const source = raw ?? {}
+  for (const [key, fieldId] of Object.entries(fieldIds)) {
+    if (String(fieldId) in source) {
+      out[key] = source[String(fieldId)]
+    }
+  }
+  return out as T
+}
+
+export function toArcubaseColumn(column: string, fieldIds: Record<string, number>): string {
+  return fieldIds[column] ? \`:\${fieldIds[column]}\` : column
+}
+
+export function mapArcubaseCondition(value: unknown, fieldIds: Record<string, number>): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapArcubaseCondition(item, fieldIds))
+  }
+  if (!value || typeof value !== 'object') {
+    return value
+  }
+  const out: Record<string, unknown> = {}
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    if (key === 'column' && typeof child === 'string') {
+      out[key] = toArcubaseColumn(child, fieldIds)
+    } else {
+      const mappedKey = fieldIds[key] ? \`:\${fieldIds[key]}\` : key
+      out[mappedKey] = mapArcubaseCondition(child, fieldIds)
     }
-    throw error
+  }
+  return out
+}
+
+export function mapArcubaseSorts<T extends { column: string; order?: string }>(sorts: T[] | undefined, fieldIds: Record<string, number>): T[] | undefined {
+  return sorts?.map((sort) => ({ ...sort, column: toArcubaseColumn(sort.column, fieldIds) }))
+}
+`
+}
+
+function emitSchema(ingresses: ArcubaseIngress[]): string {
+  const schema = {
+    ingresses: Object.fromEntries(ingresses.map((ingress) => [
+      ingress.key,
+      {
+        appId: ingress.appId,
+        ingressId: ingress.hashId,
+        entityId: ingress.entity.id,
+        name: ingress.name,
+        actions: ingress.actions,
+        fields: Object.fromEntries(allFields(ingress.entity).map((field) => [
+          field.key,
+          {
+            fieldId: field.id,
+            label: field.label,
+            type: field.type,
+            required: field.required,
+          },
+        ])),
+      },
+    ])),
+  }
+  return `export const arcubaseSchema = ${JSON.stringify(schema, null, 2)} as const
+
+export type ArcubaseIngressKey = keyof typeof arcubaseSchema.ingresses
+`
+}
+
+function emitIngress(ingress: ArcubaseIngress): string {
+  const typeName = toPascalCase(ingress.key)
+  const fields = allFields(ingress.entity)
+  const fieldLines = fields.map((field) => {
+    const optional = field.required ? '' : '?'
+    return `  ${field.key}${optional}: ${normalizeFieldType(field.type)}`
+  })
+  const fieldMapLines = fields.map((field) => `  ${field.key}: ${field.id},`)
+  const methodChunks: string[] = []
+
+  if (hasAction(ingress, 'view')) {
+    methodChunks.push(`    async query(params: ${typeName}QueryParams = {}): Promise<{ items: ArcubaseRow<${typeName}Fields>[]; total?: number; offset?: number; limit?: number }> {
+      const data = await runtime.request<{ items?: Record<string, any>[]; total?: number; offset?: number; limit?: number }>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/data-query\`, {
+        ...params,
+        policy_id: ingressId,
+        search: mapArcubaseCondition(params.search, fieldIds),
+        sorts: mapArcubaseSorts(params.sorts, fieldIds),
+      })
+      return {
+        items: (data.items ?? []).map(mapRow),
+        total: data.total,
+        offset: data.offset,
+        limit: data.limit,
+      }
+    },
+
+    async get(rowId: string | number): Promise<ArcubaseRow<${typeName}Fields>> {
+      const data = await runtime.request<{ record?: Record<string, any> }>('GET', \`/entity/${ingress.appId}/${ingress.entity.id}/row/\${rowId}?policy_id=\${encodeURIComponent(ingressId)}\`)
+      return mapRow(data.record ?? {})
+    },`)
+  }
+
+  if (hasAction(ingress, 'add')) {
+    methodChunks.push(`    async prepareCreate(): Promise<Record<string, any>> {
+      return runtime.request<Record<string, any>>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/prepare\`, {
+        policy_id: ingressId,
+      })
+    },
+
+    async create(fields: ${typeName}CreateInput): Promise<number> {
+      return runtime.request<number>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/insert\`, {
+        fields: toArcubaseFields(fields, fieldIds),
+        policy_id: ingressId,
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'edit')) {
+    methodChunks.push(`    async update(rowId: string | number, fields: ${typeName}UpdateInput): Promise<boolean> {
+      const data = toArcubaseFields(fields, fieldIds)
+      return runtime.request<boolean>('PUT', \`/entity/${ingress.appId}/${ingress.entity.id}/row/\${rowId}\`, {
+        data,
+        changed_fields: Object.keys(data).map((fieldId) => Number(fieldId)),
+        policy_id: ingressId,
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'delete')) {
+    methodChunks.push(`    async delete(selection: ${typeName}Selection): Promise<{ deleted?: number } | boolean> {
+      return runtime.request<{ deleted?: number } | boolean>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/delete-item\`, {
+        policy_id: ingressId,
+        selection: toArcubaseSelection(selection),
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'bulk_update')) {
+    methodChunks.push(`    async bulkUpdate(selection: ${typeName}Selection, fields: ${typeName}BulkUpdateField[]): Promise<{ updated: number }> {
+      return runtime.request<{ updated: number }>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/bulk-update\`, {
+        policy_id: ingressId,
+        selection: toArcubaseSelection(selection),
+        fields: fields.map((field) => ({
+          id: fieldIds[field.key],
+          action: field.action,
+        })),
+      })
+    },
+
+    async saveBulkUpdate(input: { name: string; subject: string; fields: ${typeName}BulkUpdateField[] }): Promise<string> {
+      return runtime.request<string>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/bulk-update-save-as\`, {
+        name: input.name,
+        subject: input.subject,
+        fields: input.fields.map((field) => ({
+          id: fieldIds[field.key],
+          action: field.action,
+        })),
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'export')) {
+    methodChunks.push(`    async exportRows(options: ${typeName}ExportOptions = {}): Promise<{ task_id: string }> {
+      const fieldKeys = options.fields ?? Object.keys(fieldIds) as ${typeName}FieldKey[]
+      return runtime.request<{ task_id: string }>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/export\`, {
+        policy_id: ingressId,
+        props: options.props ?? [],
+        fields: fieldKeys.map((key) => fieldIds[key]),
+        propnames: options.propNames ?? {},
+        options: { has_id: options.hasIdField ?? false },
+      })
+    },
+
+    async exportTask(taskId: string): Promise<Record<string, any>> {
+      return runtime.request<Record<string, any>>('GET', \`/export-task/\${taskId}\`)
+    },`)
+  }
+
+  if (hasAction(ingress, 'batch_print')) {
+    methodChunks.push(`    async batchPrint(selection: ${typeName}Selection, params: { limit?: number; offset?: number } = {}): Promise<{ items?: Record<string, any>[]; total?: number }> {
+      return runtime.request<{ items?: Record<string, any>[]; total?: number }>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/selection-query/batch_print\`, {
+        ...params,
+        policy_id: ingressId,
+        selection: toArcubaseSelection(selection),
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'archive')) {
+    methodChunks.push(`    async archive(selection: ${typeName}Selection): Promise<{ archived?: number } | boolean> {
+      return runtime.request<{ archived?: number } | boolean>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/selection-query/archive\`, {
+        policy_id: ingressId,
+        selection: toArcubaseSelection(selection),
+      })
+    },`)
+  }
+
+  if (hasAction(ingress, 'tag_manage')) {
+    methodChunks.push(`    tags: {
+      async list(): Promise<string[]> {
+        return runtime.request<string[]>('GET', \`/user-action-entity/${ingress.appId}/${ingress.entity.id}/tag-names\`)
+      },
+      async add(selection: ${typeName}Selection, tagNames: string[]): Promise<Record<string, any>> {
+        return runtime.request<Record<string, any>>('POST', \`/user-action-entity/${ingress.appId}/${ingress.entity.id}/batch-add-tags\`, {
+          policy_id: ingressId,
+          selection: toArcubaseSelection(selection),
+          tag_names: tagNames,
+        })
+      },
+      async remove(selection: ${typeName}Selection, tagNames: string[]): Promise<boolean> {
+        return runtime.request<boolean>('POST', \`/user-action-entity/${ingress.appId}/${ingress.entity.id}/batch-remove-tags\`, {
+          policy_id: ingressId,
+          selection: toArcubaseSelection(selection),
+          tag_names: tagNames,
+        })
+      },
+      async selection(selection: ${typeName}Selection): Promise<string[]> {
+        return runtime.request<string[]>('POST', \`/user-action-entity/${ingress.appId}/${ingress.entity.id}/get-selection-tags\`, {
+          policy_id: ingressId,
+          selection: toArcubaseSelection(selection),
+        })
+      },
+    },`)
+  }
+
+  const customActions = ingress.actions.filter((action) => !['view', 'add', 'edit', 'delete', 'bulk_update', 'export', 'batch_print', 'archive', 'tag_manage'].includes(action))
+  if (customActions.length > 0) {
+    methodChunks.push(`    async action(action: ${typeName}CustomAction, payload: Record<string, any> = {}): Promise<Record<string, any>> {
+      if (!allowedActions.includes(action)) {
+        throw new Error(\`Action is not allowed for ${ingress.key}: \${action}\`)
+      }
+      return runtime.request<Record<string, any>>('POST', \`/entity/${ingress.appId}/${ingress.entity.id}/selection-query/\${encodeURIComponent(action)}\`, {
+        ...payload,
+        policy_id: ingressId,
+        selection: payload.selection ? toArcubaseSelection(payload.selection) : undefined,
+      })
+    },`)
+  }
+
+  return `import {
+  fromArcubaseFields,
+  mapArcubaseCondition,
+  mapArcubaseSorts,
+  toArcubaseFields,
+  type ArcubaseRow,
+  type ArcubaseRuntime,
+} from '../runtime.js'
+
+export type ${typeName}FieldKey = ${fields.map((field) => `'${field.key}'`).join(' | ')}
+
+export type ${typeName}Fields = {
+${fieldLines.join('\n')}
+}
+
+export type ${typeName}CreateInput = ${typeName}Fields
+export type ${typeName}UpdateInput = Partial<${typeName}Fields>
+export type ${typeName}Action = ${ingress.actions.map((action) => `'${action}'`).join(' | ') || 'never'}
+export type ${typeName}CustomAction = ${customActions.map((action) => `'${action}'`).join(' | ') || 'never'}
+
+export type ${typeName}Sort = {
+  column: ${typeName}FieldKey | 'id' | 'created_at' | 'updated_at' | 'creator' | string
+  order: 'asc' | 'desc'
+}
+
+export type ${typeName}QueryParams = {
+  limit?: number
+  offset?: number
+  search?: Record<string, any>
+  sorts?: ${typeName}Sort[]
+  view_mode?: 'normal' | 'deleted' | 'archived'
+  withSubForm?: boolean
+}
+
+export type ${typeName}Selection = {
+  type: 'ids' | 'condition'
+  length?: number
+  ids?: Array<number | string>
+  condition?: Record<string, any>
+  sorts?: ${typeName}Sort[]
+}
+
+export type ${typeName}BulkUpdateField = {
+  key: ${typeName}FieldKey
+  action: Record<string, any>
+}
+
+export type ${typeName}ExportOptions = {
+  fields?: ${typeName}FieldKey[]
+  props?: string[]
+  propNames?: Record<string, string>
+  hasIdField?: boolean
+}
+
+const ingressId = ${JSON.stringify(ingress.hashId)}
+const fieldIds = {
+${fieldMapLines.join('\n')}
+} as const
+const allowedActions = ${JSON.stringify(customActions)} as const
+
+function mapRow(raw: Record<string, any>): ArcubaseRow<${typeName}Fields> {
+  return {
+    id: Number(raw.id),
+    title: typeof raw.title === 'string' ? raw.title : undefined,
+    fields: fromArcubaseFields<${typeName}Fields>(raw.fields, fieldIds),
+    raw,
+  }
+}
+
+function toArcubaseSelection(selection: ${typeName}Selection): Record<string, any> {
+  return {
+    ...selection,
+    condition: mapArcubaseCondition(selection.condition ?? {}, fieldIds),
+    sorts: mapArcubaseSorts(selection.sorts, fieldIds),
+  }
+}
+
+export function create${typeName}Ingress(runtime: ArcubaseRuntime) {
+  return {
+${methodLines(methodChunks)}  }
+}
+`
+}
+
+function emitClient(ingresses: ArcubaseIngress[]): string {
+  const imports = ingresses.map((ingress) => {
+    const typeName = toPascalCase(ingress.key)
+    return `import { create${typeName}Ingress } from './ingresses/${ingress.key}.js'`
+  })
+  const mapLines = ingresses.map((ingress) => `  ${JSON.stringify(ingress.key)}: ReturnType<typeof create${toPascalCase(ingress.key)}Ingress>`)
+  const cases = ingresses.map((ingress) => `        case ${JSON.stringify(ingress.key)}:
+          return create${toPascalCase(ingress.key)}Ingress(runtime) as ArcubaseIngressMap[K]`)
+  return `import { createRuntime, type ArcubaseClientConfig } from './runtime.js'
+${imports.join('\n')}
+
+export type ArcubaseIngressMap = {
+${mapLines.join('\n')}
+}
+
+export type ArcubaseIngressKey = keyof ArcubaseIngressMap
+
+export function createArcubaseClient(config: ArcubaseClientConfig) {
+  const runtime = createRuntime(config)
+  return {
+    ingress<K extends ArcubaseIngressKey>(key: K): ArcubaseIngressMap[K] {
+      switch (key) {
+${cases.join('\n')}
+        default:
+          throw new Error(\`Unknown Arcubase ingress: \${String(key)}\`)
+      }
+    },
+  }
+}
+`
+}
+
+function emitIndex(ingresses: ArcubaseIngress[]): string {
+  return `export { createArcubaseClient } from './client.js'
+export type { ArcubaseClientConfig, ArcubaseRow } from './runtime.js'
+export { arcubaseSchema } from './schema.js'
+export type { ArcubaseIngressKey, ArcubaseIngressMap } from './client.js'
+${ingresses.map((ingress) => {
+  const typeName = toPascalCase(ingress.key)
+  return `export type { ${typeName}Fields, ${typeName}CreateInput, ${typeName}UpdateInput, ${typeName}FieldKey, ${typeName}Selection } from './ingresses/${ingress.key}.js'`
+}).join('\n')}
+`
+}
+
+export function generateArcubaseProjectSDK(payload: unknown): GeneratedSDK {
+  const ingresses = normalizeIngresses(payload)
+  return {
+    files: [
+      { path: 'runtime.ts', contents: emitRuntime() },
+      { path: 'schema.ts', contents: emitSchema(ingresses) },
+      ...ingresses.map((ingress) => ({ path: `ingresses/${ingress.key}.ts`, contents: emitIngress(ingress) })),
+      { path: 'client.ts', contents: emitClient(ingresses) },
+      { path: 'index.ts', contents: emitIndex(ingresses) },
+    ],
   }
 }