@carthooks/arcubase-cli 0.1.26 → 0.1.27

package/dist/runtime/dev_sdk_gen.js

@@ -1,598 +0,0 @@
-import { CLIError } from './errors.js';
-const identifierPattern = /^[A-Za-z][A-Za-z0-9_]*$/;
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function unwrapData(payload) {
-    return isRecord(payload) && 'data' in payload ? payload.data : payload;
-}
-function toPascalCase(value) {
-    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) {
-    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) {
-    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) => isRecord(child))
-            .map(normalizeField)
-            .filter((child) => 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, appId) {
-    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) => isRecord(field))
-            .map(normalizeField)
-            .filter((field) => Boolean(field))
-        : [];
-    return {
-        appId,
-        id: payload.id,
-        name: payload.name,
-        fields,
-    };
-}
-function normalizeActions(ingress) {
-    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) => typeof action === 'string' && action.trim() !== '').map((action) => action.trim());
-}
-function normalizeIngresses(payload) {
-    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) => 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, visit) {
-    for (const field of fields) {
-        visit(field);
-        if (field.children && field.children.length > 0) {
-            walkFields(field.children, visit);
-        }
-    }
-}
-function allFields(entity) {
-    const out = [];
-    walkFields(entity.fields, (field) => out.push(field));
-    return out;
-}
-function validateIngresses(ingresses) {
-    const ingressKeys = new Set();
-    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();
-        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, action) {
-    return ingress.actions.includes(action);
-}
-function methodLines(lines) {
-    return lines.length > 0 ? `${lines.join('\n\n')}\n` : '';
-}
-function emitRuntime() {
-    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)
-    }
-  }
-  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) {
-    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) {
-    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 = [];
-    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) {
-    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) {
-    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) {
-    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) },
-        ],
-    };
-}