@nocobase/ctl 0.1.5

package/dist/lib/runtime-generator.js

@@ -0,0 +1,383 @@
+import { createHash } from 'node:crypto';
+import { loadBuildConfig } from "./build-config.js";
+import { toKebabCase, toLogicalActionName, toLogicalResourceName, toResourceSegments } from "./naming.js";
+import { collectOperations } from "./openapi.js";
+const RESERVED_FLAG_NAMES = new Set(['base-url', 'env', 'token', 'json-output', 'body', 'body-file']);
+function matchesPattern(value, pattern) {
+    if (!value) {
+        return false;
+    }
+    if (pattern.endsWith('*')) {
+        return value.startsWith(pattern.slice(0, -1));
+    }
+    return value === pattern;
+}
+function inferParameterType(schema) {
+    if (schema?.type) {
+        return schema.type;
+    }
+    for (const candidate of [...(schema?.oneOf ?? []), ...(schema?.anyOf ?? []), ...(schema?.allOf ?? [])]) {
+        const resolved = inferParameterType(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return undefined;
+}
+function createUniqueFlagName(baseName, usedFlagNames) {
+    let candidate = baseName || 'value';
+    if (RESERVED_FLAG_NAMES.has(candidate)) {
+        candidate = `param-${candidate}`;
+    }
+    if (!usedFlagNames.has(candidate)) {
+        usedFlagNames.add(candidate);
+        return candidate;
+    }
+    let index = 2;
+    while (usedFlagNames.has(`${candidate}-${index}`)) {
+        index += 1;
+    }
+    const unique = `${candidate}-${index}`;
+    usedFlagNames.add(unique);
+    return unique;
+}
+function isSupportedParameter(parameter) {
+    return Boolean(parameter && typeof parameter.name === 'string' && typeof parameter.in === 'string');
+}
+function toGeneratedParameter(parameter, usedFlagNames) {
+    return {
+        name: parameter.name,
+        flagName: createUniqueFlagName(toKebabCase(parameter.name), usedFlagNames),
+        in: parameter.in,
+        required: parameter.required,
+        description: parameter.description,
+        type: inferParameterType(parameter.schema),
+        isArray: parameter.schema?.type === 'array',
+    };
+}
+function getJsonRequestSchema(requestBody) {
+    return requestBody?.content?.['application/json']?.schema;
+}
+function normalizeCompositeSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+        return schema.allOf.reduce((result, part) => {
+            const normalized = normalizeCompositeSchema(part);
+            return {
+                ...result,
+                ...normalized,
+                type: normalized?.type ?? result.type ?? 'object',
+                properties: {
+                    ...(result.properties ?? {}),
+                    ...(normalized?.properties ?? {}),
+                },
+                required: [...new Set([...(result.required ?? []), ...(normalized?.required ?? [])])],
+                additionalProperties: normalized?.additionalProperties ?? result.additionalProperties,
+                description: schema.description ?? normalized?.description ?? result.description,
+            };
+        }, { type: 'object' });
+    }
+    return schema;
+}
+function describeSchemaShape(schema, options = {}) {
+    if (!schema) {
+        return undefined;
+    }
+    const normalizedSchema = normalizeCompositeSchema(schema);
+    if (Array.isArray(normalizedSchema?.oneOf) || Array.isArray(normalizedSchema?.anyOf)) {
+        const variants = (normalizedSchema.oneOf ?? normalizedSchema.anyOf)
+            .map((candidate) => describeSchemaShape(candidate, options))
+            .filter(Boolean);
+        return [...new Set(variants)].join(' | ') || 'value';
+    }
+    if (normalizedSchema.$ref && typeof normalizedSchema.$ref === 'string') {
+        return normalizedSchema.$ref.split('/').pop();
+    }
+    const depth = options.depth ?? 0;
+    const maxDepth = options.maxDepth ?? 2;
+    const maxProperties = options.maxProperties ?? 6;
+    const type = inferParameterType(normalizedSchema) ??
+        (normalizedSchema.properties ? 'object' : undefined) ??
+        (normalizedSchema.items ? 'array' : undefined) ??
+        (normalizedSchema.additionalProperties ? 'object' : undefined);
+    if (!type) {
+        return 'value';
+    }
+    if (type === 'array') {
+        const itemShape = describeSchemaShape(normalizedSchema.items, {
+            depth: depth + 1,
+            maxDepth,
+            maxProperties,
+        });
+        return itemShape ? `[${itemShape}]` : '[]';
+    }
+    if (type === 'object') {
+        const properties = Object.entries(normalizedSchema.properties ?? {});
+        if (!properties.length) {
+            return undefined;
+        }
+        const required = new Set(normalizedSchema.required ?? []);
+        const sortedProperties = [...properties].sort(([left], [right]) => Number(required.has(right)) - Number(required.has(left)));
+        return `{${sortedProperties
+            .slice(0, maxProperties)
+            .map(([name, propertySchema]) => {
+            const nestedShape = depth + 1 < maxDepth ? describeSchemaShape(propertySchema, { depth: depth + 1, maxDepth, maxProperties }) : undefined;
+            return `${name}${required.has(name) ? '' : '?'}: ${nestedShape ?? inferParameterType(propertySchema) ?? 'value'}`;
+        })
+            .join(', ')}${sortedProperties.length > maxProperties ? ', ...' : ''}}`;
+    }
+    return type;
+}
+function extractBodyParameters(requestBody, usedFlagNames) {
+    const schema = getJsonRequestSchema(requestBody);
+    const properties = normalizeCompositeSchema(schema)?.properties;
+    const required = new Set(normalizeCompositeSchema(schema)?.required ?? []);
+    return Object.entries(properties ?? {}).map(([name, propertySchema]) => ({
+        name,
+        flagName: createUniqueFlagName(toKebabCase(name), usedFlagNames),
+        in: 'body',
+        required: required.has(name),
+        description: propertySchema.description,
+        type: inferParameterType(propertySchema),
+        isArray: propertySchema.type === 'array',
+        jsonEncoded: propertySchema.type === 'object' || propertySchema.type === 'array',
+        jsonShape: describeSchemaShape(propertySchema),
+    }));
+}
+function splitParagraphs(value) {
+    return (value ?? '')
+        .split(/\n\s*\n/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function resolveOperationText(operation) {
+    const swaggerSummary = operation.summary?.trim() || undefined;
+    const descriptionParagraphs = splitParagraphs(operation.description?.trim());
+    if (descriptionParagraphs.length > 0) {
+        const [summary, ...rest] = descriptionParagraphs;
+        return {
+            summary,
+            description: rest.join('\n\n') || (swaggerSummary && swaggerSummary !== summary ? swaggerSummary : undefined),
+        };
+    }
+    return {
+        summary: swaggerSummary,
+        description: undefined,
+    };
+}
+function formatFlagExample(parameter) {
+    if (parameter.type === 'boolean') {
+        return `--${parameter.flagName}`;
+    }
+    if (parameter.type === 'object') {
+        return `--${parameter.flagName} '{\"key\":\"value\"}'`;
+    }
+    if (parameter.isArray) {
+        return `--${parameter.flagName} value1 --${parameter.flagName} value2`;
+    }
+    return `--${parameter.flagName} <value>`;
+}
+function buildExamples(commandId, operation) {
+    const requiredFlags = operation.parameters.filter((parameter) => parameter.required).map(formatFlagExample);
+    const examples = [`nocobase ${commandId}${requiredFlags.length ? ` ${requiredFlags.join(' ')}` : ''}`];
+    const firstOptional = operation.parameters.find((parameter) => !parameter.required);
+    if (firstOptional) {
+        examples.push(`${examples[0]} ${formatFlagExample(firstOptional)}`);
+    }
+    if (operation.hasBody) {
+        examples.push(`${examples[0]} --body '{"key":"value"}'`);
+    }
+    return [...new Set(examples)];
+}
+function buildDescription(operation) {
+    const sections = [];
+    if (operation.description) {
+        sections.push(operation.description);
+    }
+    if (operation.moduleDisplayName || operation.moduleDescription) {
+        sections.push([operation.moduleDisplayName ? `Module: ${operation.moduleDisplayName}` : undefined, operation.moduleDescription]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    if (operation.resourceDisplayName || operation.resourceDescription) {
+        sections.push([operation.resourceDisplayName ? `Resource: ${operation.resourceDisplayName}` : undefined, operation.resourceDescription]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    sections.push(`HTTP ${operation.method.toUpperCase()} ${operation.pathTemplate}`);
+    if (operation.tags?.length) {
+        sections.push(`Tags: ${operation.tags.join(', ')}`);
+    }
+    if (operation.hasBody) {
+        const bodyFlags = operation.parameters.filter((parameter) => parameter.in === 'body').map((parameter) => `--${parameter.flagName}`);
+        sections.push(bodyFlags.length
+            ? `Request body: use body field flags (${bodyFlags.join(', ')}) or pass raw JSON via \`--body\` / \`--body-file\`.`
+            : 'Request body: JSON via `--body` or `--body-file`.');
+    }
+    return sections.join('\n\n');
+}
+function shouldIncludeResource(resourceKey, moduleConfig) {
+    if (!resourceKey) {
+        return false;
+    }
+    const includes = moduleConfig.resources?.includes;
+    const excludes = moduleConfig.resources?.excludes;
+    if (includes?.length && !includes.some((pattern) => matchesPattern(resourceKey, pattern))) {
+        return false;
+    }
+    if (excludes?.length && excludes.some((pattern) => matchesPattern(resourceKey, pattern))) {
+        return false;
+    }
+    return true;
+}
+function getPrimaryResourceKey(pathTemplate) {
+    return pathTemplate
+        .replace(/^\/+/, '')
+        .split(/[/:]/)
+        .find((segment) => segment && !segment.startsWith('{'));
+}
+function getOperationMatchKeys(operation) {
+    const normalizedPath = operation.pathTemplate.replace(/^\/+/, '');
+    const action = normalizedPath.includes(':') ? normalizedPath.slice(normalizedPath.lastIndexOf(':') + 1) : 'call';
+    const resourcePath = normalizedPath.includes(':') ? normalizedPath.slice(0, normalizedPath.lastIndexOf(':')) : normalizedPath;
+    return [
+        action,
+        operation.operationId,
+        operation.pathTemplate,
+        `${resourcePath}:${action}`,
+        `${operation.method.toLowerCase()}:${operation.pathTemplate}`,
+        `${operation.method.toUpperCase()}:${operation.pathTemplate}`,
+    ].filter((value) => Boolean(value));
+}
+function shouldIncludeOperation(operation, resourceConfig) {
+    const includes = resourceConfig?.operations?.includes;
+    const excludes = resourceConfig?.operations?.excludes;
+    const matchKeys = getOperationMatchKeys(operation);
+    if (includes?.length && !includes.some((pattern) => matchKeys.some((value) => matchesPattern(value, pattern)))) {
+        return false;
+    }
+    if (excludes?.length && excludes.some((pattern) => matchKeys.some((value) => matchesPattern(value, pattern)))) {
+        return false;
+    }
+    return true;
+}
+function scoreModuleMatch(moduleKey, moduleConfig, resourceKey, operation) {
+    if (!shouldIncludeResource(resourceKey, moduleConfig)) {
+        return -1;
+    }
+    const resourceConfig = resourceKey ? moduleConfig.resources?.overrides?.[resourceKey] : undefined;
+    if (!shouldIncludeOperation(operation, resourceConfig)) {
+        return -1;
+    }
+    let score = 10;
+    if (resourceConfig?.operations?.includes?.length) {
+        score += 100;
+    }
+    const moduleResourceNames = new Set(Object.entries(moduleConfig.resources?.overrides ?? {}).flatMap(([resourceName, resourceConfigValue]) => [
+        toKebabCase(resourceName),
+        toKebabCase(resourceConfigValue?.name ?? resourceName),
+    ]));
+    const tagTokens = (operation.tags ?? []).flatMap((tag) => tag.split(/[./:]/).map((part) => toKebabCase(part)).filter(Boolean));
+    const tokenMatches = tagTokens.filter((token) => moduleResourceNames.has(token));
+    score += tokenMatches.length * 5;
+    if (operation.pathTemplate.includes('/desktopRoutes')) {
+        score += moduleKey === 'client' ? 20 : 0;
+    }
+    return score;
+}
+function resolveModuleKey(buildConfig, operation) {
+    const resourceKey = getPrimaryResourceKey(operation.pathTemplate);
+    const candidates = Object.entries(buildConfig.modules ?? {})
+        .filter(([, moduleConfig]) => moduleConfig.include !== false)
+        .map(([moduleKey, moduleConfig]) => ({
+        moduleKey,
+        moduleConfig,
+        score: scoreModuleMatch(moduleKey, moduleConfig, resourceKey, operation),
+    }))
+        .filter((item) => item.score >= 0)
+        .sort((left, right) => right.score - left.score);
+    return candidates[0];
+}
+export async function generateRuntime(document, configFile, baseUrl) {
+    const buildConfig = await loadBuildConfig(configFile);
+    const commands = [];
+    for (const { method, pathTemplate, operation } of collectOperations(document)) {
+        const resolvedModule = resolveModuleKey(buildConfig, {
+            method,
+            pathTemplate,
+            operationId: operation.operationId,
+            tags: operation.tags,
+        });
+        if (!resolvedModule) {
+            continue;
+        }
+        const { moduleKey, moduleConfig } = resolvedModule;
+        const resourceKey = getPrimaryResourceKey(pathTemplate);
+        const resourceConfig = resourceKey ? moduleConfig.resources?.overrides?.[resourceKey] : undefined;
+        const usedFlagNames = new Set();
+        const parameters = (operation.parameters ?? []).filter(isSupportedParameter).map((parameter) => toGeneratedParameter(parameter, usedFlagNames));
+        const bodyParameters = extractBodyParameters(operation.requestBody, usedFlagNames);
+        const allParameters = [...parameters, ...bodyParameters];
+        const hasBody = Boolean(operation.requestBody && !('$ref' in operation.requestBody));
+        const moduleDisplayName = moduleConfig.name ?? moduleKey;
+        const moduleDescription = moduleConfig.description;
+        const resourceDisplayName = resourceConfig?.name ?? resourceKey;
+        const resourceDescription = resourceConfig?.description;
+        const operationText = resolveOperationText({
+            summary: operation.summary,
+            description: operation.description,
+        });
+        const resourceSegments = toResourceSegments(pathTemplate);
+        const mappedResourceSegments = resourceSegments.length && resourceConfig?.name
+            ? [toKebabCase(resourceConfig.name), ...resourceSegments.slice(1)]
+            : resourceSegments;
+        const segments = [
+            ...(resourceConfig?.topLevel ? [] : [toKebabCase(moduleDisplayName)]),
+            ...mappedResourceSegments,
+        ];
+        commands.push({
+            moduleName: moduleKey,
+            moduleDisplayName,
+            moduleDescription,
+            resourceName: resourceKey,
+            logicalResourceName: toLogicalResourceName(pathTemplate),
+            actionName: toLogicalActionName(pathTemplate),
+            resourceDisplayName,
+            resourceDescription,
+            commandId: segments.join(' '),
+            method,
+            pathTemplate,
+            tags: operation.tags,
+            summary: operationText.summary ?? `${method.toUpperCase()} ${pathTemplate}`,
+            description: buildDescription({
+                moduleDisplayName: resourceConfig?.topLevel ? undefined : moduleDisplayName,
+                moduleDescription: resourceConfig?.topLevel ? undefined : moduleDescription,
+                resourceDisplayName,
+                resourceDescription,
+                method,
+                pathTemplate,
+                tags: operation.tags,
+                description: operationText.description,
+                hasBody,
+                parameters: allParameters,
+            }),
+            examples: buildExamples(segments.join(' '), {
+                parameters: allParameters,
+                hasBody,
+            }),
+            parameters: allParameters,
+            hasBody,
+            bodyRequired: operation.requestBody && !('$ref' in operation.requestBody) ? operation.requestBody.required : undefined,
+        });
+    }
+    const schemaHash = createHash('sha1').update(JSON.stringify(document)).digest('hex').slice(0, 8);
+    return {
+        version: String(document.info?.version ?? 'unknown'),
+        schemaHash,
+        generatedAt: new Date().toISOString(),
+        baseUrl,
+        commands: commands.sort((left, right) => left.commandId.localeCompare(right.commandId)),
+    };
+}

package/dist/lib/runtime-store.js

@@ -0,0 +1,56 @@
+import fs, { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { resolveCliHomeDir } from "./cli-home.js";
+function getHomeDir(options = {}) {
+    return resolveCliHomeDir(options.scope);
+}
+export function getVersionsDir(options = {}) {
+    return path.join(getHomeDir(options), 'versions');
+}
+export function getVersionDir(version, options = {}) {
+    return path.join(getVersionsDir(options), version);
+}
+function getRuntimeFile(version, options = {}) {
+    return path.join(getVersionDir(version, options), 'commands.json');
+}
+export async function saveRuntime(runtime, options = {}) {
+    const versionDir = getVersionDir(runtime.version, options);
+    await fsp.mkdir(versionDir, { recursive: true });
+    await fsp.writeFile(getRuntimeFile(runtime.version, options), JSON.stringify(runtime, null, 2));
+}
+export async function loadRuntime(version, options = {}) {
+    try {
+        const content = await fsp.readFile(getRuntimeFile(version, options), 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+export function loadRuntimeSync(version, options = {}) {
+    if (!version) {
+        return undefined;
+    }
+    try {
+        const content = fs.readFileSync(getRuntimeFile(version, options), 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+export async function listRuntimes(options = {}) {
+    try {
+        const entries = await fsp.readdir(getVersionsDir(options), { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    }
+    catch (error) {
+        return [];
+    }
+}
+export async function deleteRuntime(version, options = {}) {
+    await fsp.rm(getVersionDir(version, options), { recursive: true, force: true });
+}
+export function hasRuntimeSync(version, options = {}) {
+    return version ? fs.existsSync(getRuntimeFile(version, options)) : false;
+}

package/dist/lib/ui.js

@@ -0,0 +1,154 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import ora from 'ora';
+import pc from 'picocolors';
+let activeSpinner;
+let verboseMode = false;
+function stringWidth(value) {
+    return Array.from(value).length;
+}
+function pad(value, width) {
+    const padding = Math.max(0, width - stringWidth(value));
+    return `${value}${' '.repeat(padding)}`;
+}
+export function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+export function setVerboseMode(value) {
+    verboseMode = value;
+}
+export function isVerboseMode() {
+    return verboseMode;
+}
+export async function promptText(message, options) {
+    if (!isInteractiveTerminal()) {
+        return options?.defaultValue ?? '';
+    }
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? ` (${options.defaultValue})` : '';
+        const hint = options?.secret ? ' [input visible]' : '';
+        const prompt = `${message}${suffix}${hint}: `;
+        const answer = await rl.question(prompt);
+        return answer.trim() || options?.defaultValue || '';
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function confirmAction(message, options) {
+    if (!isInteractiveTerminal()) {
+        return Boolean(options?.defaultValue);
+    }
+    stopTask();
+    const rl = readline.createInterface({
+        input,
+        output,
+        terminal: true,
+    });
+    try {
+        const suffix = options?.defaultValue ? pc.dim('[Y/n]') : pc.dim('[y/N]');
+        const prompt = `${pc.yellow('?')} ${pc.bold(message)} ${suffix} `;
+        const answer = await rl.question(prompt);
+        const normalized = answer.trim().toLowerCase();
+        if (!normalized) {
+            return Boolean(options?.defaultValue);
+        }
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export function printSection(title) {
+    console.log(pc.bold(title));
+}
+export function printInfo(message) {
+    if (activeSpinner) {
+        activeSpinner.info(pc.cyan(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.cyan(message));
+}
+export function printVerbose(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printInfo(message);
+}
+export function printSuccess(message) {
+    if (activeSpinner) {
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+export function printWarning(message) {
+    if (activeSpinner) {
+        activeSpinner.warn(pc.yellow(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.yellow(message));
+}
+export function printVerboseWarning(message) {
+    if (!verboseMode) {
+        return;
+    }
+    printWarning(message);
+}
+export function startTask(message) {
+    if (activeSpinner) {
+        activeSpinner.stop();
+    }
+    activeSpinner = ora({
+        text: pc.cyan(message),
+        isSilent: !isInteractiveTerminal(),
+    }).start();
+    if (!isInteractiveTerminal()) {
+        console.log(pc.cyan(message));
+    }
+}
+export function updateTask(message) {
+    if (!activeSpinner) {
+        startTask(message);
+        return;
+    }
+    activeSpinner.text = pc.cyan(message);
+}
+export function succeedTask(message) {
+    if (activeSpinner) {
+        activeSpinner.succeed(pc.green(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.log(pc.green(message));
+}
+export function failTask(message) {
+    if (activeSpinner) {
+        activeSpinner.fail(pc.red(message));
+        activeSpinner = undefined;
+        return;
+    }
+    console.error(pc.red(message));
+}
+export function stopTask() {
+    if (activeSpinner) {
+        activeSpinner.stop();
+        activeSpinner = undefined;
+    }
+}
+export function renderTable(headers, rows) {
+    const widths = headers.map((header, index) => {
+        return rows.reduce((max, row) => Math.max(max, stringWidth(row[index] ?? '')), stringWidth(header));
+    });
+    const renderRow = (row) => row.map((cell, index) => pad(cell ?? '', widths[index])).join('  ').trimEnd();
+    const divider = widths.map((width) => '-'.repeat(width)).join('  ');
+    return [renderRow(headers), divider, ...rows.map(renderRow)].join('\n');
+}

package/dist/post-processors/data-modeling.js

@@ -0,0 +1,66 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { postProcessorRegistry } from "../lib/post-processors.js";
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value?.data)) {
+        return value.data;
+    }
+    return [];
+}
+function pickCollectionSummary(item) {
+    return {
+        key: item?.key,
+        name: item?.name,
+        title: item?.title,
+        description: item?.description,
+    };
+}
+function pickFieldSummary(item) {
+    return {
+        key: item?.key,
+        name: item?.name,
+        type: item?.type,
+        title: item?.uiSchema?.title,
+        description: item?.description,
+        collectionName: item?.collectionName,
+    };
+}
+function simplifyCollectionsListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickCollectionSummary(item)),
+        meta: result?.meta,
+        nextActions: [
+            'Use collections:get with filterByTk=<collectionName> to inspect one collection in detail.',
+            'Use collections:apply with --verify when you need normalized verification in the same response.',
+        ],
+    };
+}
+function simplifyFieldsListResult(result) {
+    const items = toArray(result);
+    return {
+        data: items.map((item) => pickFieldSummary(item)),
+        meta: result?.meta,
+    };
+}
+export function registerDataModelingPostProcessors() {
+    postProcessorRegistry.register('collections', 'list', simplifyCollectionsListResult);
+    postProcessorRegistry.register('collections', 'apply', (result) => ({
+        data: pickCollectionSummary(result?.data || {}),
+        verify: result?.verify,
+    }));
+    postProcessorRegistry.register('collections', 'verify', (result) => result);
+    postProcessorRegistry.register('fields', 'apply', (result) => ({
+        data: pickFieldSummary(result?.data || {}),
+    }));
+    postProcessorRegistry.register('collections.fields', 'list', simplifyFieldsListResult);
+}