@nocobase/ctl 0.1.5

package/dist/lib/generated-command.js

@@ -0,0 +1,113 @@
+import { Command, Flags } from '@oclif/core';
+import { executeApiRequest } from "./api-client.js";
+import { applyPostProcessor } from "./post-processors.js";
+import { registerPostProcessors } from "../post-processors/index.js";
+function buildParameterFlag(parameter) {
+    const hints = [parameter.in];
+    if (parameter.type === 'object' || parameter.type === 'array' || parameter.jsonEncoded) {
+        hints.push('JSON');
+    }
+    else if (parameter.isArray) {
+        hints.push('repeatable');
+    }
+    else if (parameter.type) {
+        hints.push(parameter.type);
+    }
+    const description = [
+        `${parameter.description ?? ''}${parameter.description ? ' ' : ''}[${hints.join(', ')}]`.trim(),
+        parameter.jsonShape ? `Shape: ${parameter.jsonShape}` : undefined,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    if (parameter.type === 'boolean') {
+        return Flags.boolean({
+            description,
+            ...(parameter.required ? { required: true } : {}),
+        });
+    }
+    if (parameter.isArray && !parameter.jsonEncoded) {
+        return Flags.string({
+            description,
+            multiple: true,
+            ...(parameter.required ? { required: true } : {}),
+        });
+    }
+    return Flags.string({
+        description,
+        ...(parameter.required ? { required: true } : {}),
+    });
+}
+export function createGeneratedFlags(operation) {
+    const flags = {
+        'base-url': Flags.string({
+            description: 'NocoBase API base URL, for example http://localhost:13000/api',
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'Environment name',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'Bearer token override',
+        }),
+        'json-output': Flags.boolean({
+            char: 'j',
+            description: 'Print raw JSON response',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    for (const parameter of operation.parameters) {
+        flags[parameter.flagName] = buildParameterFlag(parameter);
+    }
+    if (operation.hasBody) {
+        flags.body = Flags.string({
+            description: 'JSON request body string',
+            required: operation.bodyRequired,
+            exclusive: ['body-file'],
+        });
+        flags['body-file'] = Flags.string({
+            description: 'Path to JSON request body file',
+            required: false,
+            exclusive: ['body'],
+        });
+    }
+    return flags;
+}
+export class GeneratedApiCommand extends Command {
+    static operation;
+    async run() {
+        registerPostProcessors();
+        const ctor = this.constructor;
+        const { flags } = await this.parse(ctor);
+        const response = await executeApiRequest({
+            envName: flags.env,
+            baseUrl: flags['base-url'],
+            token: flags.token,
+            flags,
+            operation: {
+                method: ctor.operation.method,
+                pathTemplate: ctor.operation.pathTemplate,
+                parameters: ctor.operation.parameters,
+                hasBody: ctor.operation.hasBody,
+                bodyRequired: ctor.operation.bodyRequired,
+            },
+        });
+        if (!response.ok) {
+            this.error(`Request failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`);
+        }
+        const processedData = await applyPostProcessor(response.data, {
+            flags,
+            operation: ctor.operation,
+        });
+        if (flags['json-output']) {
+            this.log(JSON.stringify(processedData, null, 2));
+            return;
+        }
+        this.log(`HTTP ${response.status}`);
+    }
+}

package/dist/lib/naming.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+export function toKebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}
+export function splitPathAction(pathTemplate) {
+    const normalizedPath = pathTemplate.replace(/^\/+/, '');
+    const separatorIndex = normalizedPath.lastIndexOf(':');
+    if (separatorIndex === -1) {
+        return {
+            resourcePath: normalizedPath,
+            action: 'call',
+        };
+    }
+    return {
+        resourcePath: normalizedPath.slice(0, separatorIndex),
+        action: normalizedPath.slice(separatorIndex + 1),
+    };
+}
+export function toLogicalResourceName(pathTemplate) {
+    const { resourcePath } = splitPathAction(pathTemplate);
+    return resourcePath
+        .split('/')
+        .filter(Boolean)
+        .filter((segment) => !segment.startsWith('{'))
+        .map((segment) => toKebabCase(segment))
+        .join('.');
+}
+export function toLogicalActionName(pathTemplate) {
+    return toKebabCase(splitPathAction(pathTemplate).action);
+}
+export function toResourceSegments(pathTemplate, options) {
+    const { resourcePath, action } = splitPathAction(pathTemplate);
+    const pathSegments = resourcePath
+        .split('/')
+        .filter(Boolean)
+        .flatMap((segment) => {
+        if (!segment.startsWith('{')) {
+            return [toKebabCase(segment)];
+        }
+        if (!options?.includeParams) {
+            return [];
+        }
+        return [`by-${toKebabCase(segment.slice(1, -1))}`];
+    });
+    return [...pathSegments, toKebabCase(action)].filter(Boolean);
+}
+export function toCommandSegments(moduleName, pathTemplate, options) {
+    const resourceSegments = toResourceSegments(pathTemplate, options);
+    const segments = [options?.omitModule ? '' : toKebabCase(moduleName), ...resourceSegments].filter(Boolean);
+    return segments.length ? segments : [toKebabCase(moduleName), 'call'];
+}
+export function toClassName(segments) {
+    return segments
+        .map((segment) => segment.replace(/(^\w|-\w)/g, (token) => token.replace('-', '').toUpperCase()))
+        .join('');
+}
+export function toOutputFile(outputRoot, segments) {
+    const folder = path.join(outputRoot, ...segments.slice(0, -1));
+    const filePath = path.join(folder, `${segments.at(-1)}.ts`);
+    return filePath;
+}
+export function toImportPath(fromFile, targetFile) {
+    const relative = path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}

package/dist/lib/openapi.js

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import SwaggerParser from '@apidevtools/swagger-parser';
+import ts from 'typescript';
+const SWAGGER_FILENAMES = new Set(['index.json', 'index.ts', 'swagger.json']);
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+function isPluginSwaggerSource(filePath) {
+    return (filePath.includes(`${path.sep}packages${path.sep}plugins${path.sep}`) &&
+        filePath.includes(`${path.sep}src${path.sep}swagger${path.sep}`));
+}
+function isCoreSwaggerSource(filePath) {
+    return filePath.includes(`${path.sep}packages${path.sep}core${path.sep}server${path.sep}src${path.sep}swagger${path.sep}`);
+}
+function toModuleName(filePath) {
+    if (isCoreSwaggerSource(filePath)) {
+        return 'core';
+    }
+    const normalized = filePath.replace(/\\/g, '/');
+    const pluginMatch = normalized.match(/packages\/plugins\/@nocobase\/plugin-([^/]+)\//);
+    return pluginMatch?.[1] ?? '';
+}
+function toPackageFile(filePath) {
+    if (isCoreSwaggerSource(filePath)) {
+        return '';
+    }
+    const normalized = filePath.replace(/\\/g, '/');
+    const match = normalized.match(/^(.*\/packages\/plugins\/@nocobase\/plugin-[^/]+)\//);
+    return match ? `${match[1]}/package.json` : '';
+}
+function toPackageName(filePath) {
+    if (isCoreSwaggerSource(filePath)) {
+        return '@nocobase/server';
+    }
+    const normalized = filePath.replace(/\\/g, '/');
+    const match = normalized.match(/packages\/plugins\/(@nocobase\/plugin-[^/]+)\//);
+    return match?.[1] ?? '';
+}
+async function walk(dir, result) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walk(fullPath, result);
+            continue;
+        }
+        if (!SWAGGER_FILENAMES.has(entry.name)) {
+            continue;
+        }
+        if (!isPluginSwaggerSource(fullPath) && !isCoreSwaggerSource(fullPath)) {
+            continue;
+        }
+        result.push(fullPath);
+    }
+}
+export async function discoverSwaggerSources(sourceRoot) {
+    const files = [];
+    await walk(path.join(sourceRoot, 'packages'), files);
+    return files
+        .sort()
+        .map((sourceFile) => ({
+        moduleName: toModuleName(sourceFile),
+        sourceFile,
+        sourceId: path.relative(sourceRoot, sourceFile).replace(/\\/g, '/'),
+        packageFile: toPackageFile(sourceFile) || undefined,
+        packageName: toPackageName(sourceFile) || undefined,
+        format: sourceFile.endsWith('.json') ? 'json' : 'ts',
+    }))
+        .filter((item) => item.moduleName);
+}
+function getPropertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    if (ts.isComputedPropertyName(name) && ts.isStringLiteral(name.expression)) {
+        return name.expression.text;
+    }
+    throw new Error('Unsupported computed property in swagger object.');
+}
+function evaluateExpression(node) {
+    if (ts.isObjectLiteralExpression(node)) {
+        const value = {};
+        for (const property of node.properties) {
+            if (ts.isPropertyAssignment(property)) {
+                value[getPropertyName(property.name)] = evaluateExpression(property.initializer);
+                continue;
+            }
+            if (ts.isShorthandPropertyAssignment(property)) {
+                throw new Error(`Unsupported shorthand property "${property.name.text}" in swagger object.`);
+            }
+            if (ts.isSpreadAssignment(property)) {
+                throw new Error('Unsupported spread assignment in swagger object.');
+            }
+            if (ts.isMethodDeclaration(property) || ts.isAccessor(property)) {
+                throw new Error('Unsupported method/accessor in swagger object.');
+            }
+        }
+        return value;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return node.elements.map((element) => {
+            if (ts.isSpreadElement(element)) {
+                throw new Error('Unsupported spread element in swagger array.');
+            }
+            return evaluateExpression(element);
+        });
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isNumericLiteral(node)) {
+        return Number(node.text);
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    if (node.kind === ts.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    if (node.kind === ts.SyntaxKind.NullKeyword) {
+        return null;
+    }
+    if (ts.isParenthesizedExpression(node)) {
+        return evaluateExpression(node.expression);
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return {
+            __target__: evaluateExpression(node.expression),
+            __property__: node.name.text,
+        };
+    }
+    if (ts.isCallExpression(node)) {
+        const callee = evaluateExpression(node.expression);
+        const args = node.arguments.map((argument) => evaluateExpression(argument));
+        if (callee &&
+            typeof callee === 'object' &&
+            '__target__' in callee &&
+            '__property__' in callee &&
+            callee.__property__ === 'join' &&
+            Array.isArray(callee.__target__)) {
+            return callee.__target__.join(args[0] ?? ',');
+        }
+        throw new Error('Unsupported call expression in swagger object.');
+    }
+    if (ts.isPrefixUnaryExpression(node)) {
+        const operand = evaluateExpression(node.operand);
+        if (node.operator === ts.SyntaxKind.MinusToken) {
+            return -operand;
+        }
+        if (node.operator === ts.SyntaxKind.PlusToken) {
+            return +operand;
+        }
+        if (node.operator === ts.SyntaxKind.ExclamationToken) {
+            return !operand;
+        }
+    }
+    throw new Error(`Unsupported swagger expression kind: ${ts.SyntaxKind[node.kind]}`);
+}
+function parseTypeScriptSwagger(sourceText, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement)) {
+            continue;
+        }
+        if (!ts.isObjectLiteralExpression(statement.expression)) {
+            throw new Error('Expected `export default` to be an object literal.');
+        }
+        return evaluateExpression(statement.expression);
+    }
+    throw new Error('Missing `export default` in swagger source.');
+}
+function normalizeDocument(document) {
+    return {
+        ...document,
+        openapi: document.openapi ?? '3.0.2',
+        info: {
+            ...(document.info ?? {}),
+            title: document.info?.title ?? 'NocoBase API',
+            version: document.info?.version ?? '1.0.0',
+        },
+        paths: document.paths ?? {},
+        components: document.components ?? {},
+    };
+}
+export async function loadSwaggerDocument(source) {
+    const content = await fs.readFile(source.sourceFile, 'utf8');
+    const document = normalizeDocument(source.format === 'json'
+        ? JSON.parse(content)
+        : parseTypeScriptSwagger(content, source.sourceFile));
+    try {
+        await SwaggerParser.validate(document);
+        return (await SwaggerParser.dereference(document));
+    }
+    catch (error) {
+        return document;
+    }
+}
+function resolveLocalRef(document, ref) {
+    if (!ref.startsWith('#/')) {
+        return undefined;
+    }
+    return ref
+        .slice(2)
+        .split('/')
+        .reduce((current, segment) => current?.[segment], document);
+}
+function dereferenceNode(node, document, seen = new Set()) {
+    if (Array.isArray(node)) {
+        return node.map((item) => dereferenceNode(item, document, seen));
+    }
+    if (!node || typeof node !== 'object') {
+        return node;
+    }
+    const ref = node.$ref;
+    if (typeof ref === 'string') {
+        if (seen.has(ref)) {
+            return {};
+        }
+        const resolved = resolveLocalRef(document, ref);
+        if (!resolved) {
+            return node;
+        }
+        return dereferenceNode(resolved, document, new Set([...seen, ref]));
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, dereferenceNode(value, document, seen)]));
+}
+export async function sha1File(filePath) {
+    const content = await fs.readFile(filePath);
+    return createHash('sha1').update(content).digest('hex');
+}
+export function collectOperations(document) {
+    const operations = [];
+    for (const [pathTemplate, pathItem] of Object.entries(document.paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem?.[method];
+            if (!operation || '$ref' in operation) {
+                continue;
+            }
+            const parameters = [...(pathItem.parameters ?? []), ...(operation.parameters ?? [])]
+                .map((parameter) => dereferenceNode(parameter, document))
+                .filter((parameter) => Boolean(parameter && !('$ref' in parameter)));
+            operations.push({
+                method,
+                pathTemplate,
+                operation: {
+                    ...operation,
+                    parameters,
+                    requestBody: operation.requestBody ? dereferenceNode(operation.requestBody, document) : undefined,
+                },
+            });
+        }
+    }
+    return operations;
+}

package/dist/lib/post-processors.js

@@ -0,0 +1,23 @@
+function buildKey(resource, action) {
+    return `${resource}:${action}`;
+}
+class PostProcessorRegistry {
+    processors = new Map();
+    register(resource, action, processor) {
+        this.processors.set(buildKey(resource, action), processor);
+    }
+    resolve(resource, action) {
+        if (!resource || !action) {
+            return undefined;
+        }
+        return this.processors.get(buildKey(resource, action));
+    }
+}
+export const postProcessorRegistry = new PostProcessorRegistry();
+export async function applyPostProcessor(result, context) {
+    const processor = postProcessorRegistry.resolve(context.operation.logicalResourceName, context.operation.actionName);
+    if (!processor) {
+        return result;
+    }
+    return processor(result, context);
+}