@nocobase/cli 2.1.0-alpha.16 → 2.1.0-alpha.18

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);
+}

package/dist/lib/resource-command.js

@@ -0,0 +1,335 @@
+import { Flags } from '@oclif/core';
+import { executeResourceRequest } from './resource-request.js';
+import { setVerboseMode } from './ui.js';
+function parseJson(value, flagName) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON for --${flagName}: ${error?.message ?? 'parse failed'}`);
+    }
+}
+function parseFlexibleValue(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return value;
+    }
+    if (trimmed.startsWith('[') || trimmed.startsWith('{') || trimmed === 'null' || trimmed === 'true' || trimmed === 'false') {
+        return parseJson(trimmed, flagName);
+    }
+    return value;
+}
+function parseObjectFlag(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = parseJson(value, flagName);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new Error(`--${flagName} must be a JSON object`);
+    }
+    return parsed;
+}
+function parseJsonArrayFlag(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = parseJson(value, flagName);
+    if (!Array.isArray(parsed)) {
+        throw new Error(`--${flagName} must be a JSON array`);
+    }
+    return parsed;
+}
+function parseStringArrayFlags(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            const trimmed = value[0].trim();
+            if (trimmed.startsWith('[')) {
+                const parsed = parseJson(trimmed, flagName);
+                if (!Array.isArray(parsed)) {
+                    throw new Error(`--${flagName} must be repeated or use a JSON array`);
+                }
+                return parsed.map((item) => String(item));
+            }
+        }
+        return value.map((item) => String(item));
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[')) {
+        const parsed = parseJson(trimmed, flagName);
+        if (!Array.isArray(parsed)) {
+            throw new Error(`--${flagName} must be repeated or use a JSON array`);
+        }
+        return parsed.map((item) => String(item));
+    }
+    return [String(value)];
+}
+function printResponse(command, response, jsonOutput) {
+    if (!response.ok) {
+        command.error(`Request failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`);
+    }
+    if (jsonOutput) {
+        command.log(JSON.stringify(response.data, null, 2));
+        return;
+    }
+    command.log(`HTTP ${response.status}`);
+}
+export const resourceBaseFlags = {
+    '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',
+    }),
+    role: Flags.string({
+        description: 'Role override, sent as X-Role',
+    }),
+    token: Flags.string({
+        char: 't',
+        description: 'API key override',
+    }),
+    'json-output': Flags.boolean({
+        char: 'j',
+        description: 'Print raw JSON response',
+        default: true,
+        allowNo: true,
+    }),
+    resource: Flags.string({
+        description: 'Resource name such as users, orders, or association resources like posts.comments',
+        required: true,
+    }),
+    'data-source': Flags.string({
+        description: 'Data source key. Defaults to main.',
+    }),
+};
+export const resourceAssociationFlags = {
+    'source-id': Flags.string({
+        description: 'Source record ID for association resources like posts.comments.',
+    }),
+};
+export const listFlags = {
+    ...resourceBaseFlags,
+    ...resourceAssociationFlags,
+    filter: Flags.string({
+        description: 'Filter object as JSON',
+    }),
+    fields: Flags.string({
+        description: 'Fields to query. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    appends: Flags.string({
+        description: 'Association or appended fields to include. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    except: Flags.string({
+        description: 'Fields to exclude from the result. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    sort: Flags.string({
+        description: 'Sort fields such as -createdAt. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    page: Flags.integer({
+        description: 'Page number for list action.',
+    }),
+    'page-size': Flags.integer({
+        description: 'Page size for list action.',
+    }),
+    paginate: Flags.boolean({
+        description: 'Whether to use pagination for list action.',
+        allowNo: true,
+    }),
+};
+export const getFlags = {
+    ...resourceBaseFlags,
+    ...resourceAssociationFlags,
+    'filter-by-tk': Flags.string({
+        description: 'Primary key value used by get. Supports JSON arrays for composite or multiple keys.',
+    }),
+    fields: Flags.string({
+        description: 'Fields to query. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    appends: Flags.string({
+        description: 'Association or appended fields to include. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    except: Flags.string({
+        description: 'Fields to exclude from the result. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+};
+export const createFlags = {
+    ...resourceBaseFlags,
+    ...resourceAssociationFlags,
+    values: Flags.string({
+        description: 'Record values used by create as a JSON object.',
+        required: true,
+    }),
+    whitelist: Flags.string({
+        description: 'Fields allowed to be written. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    blacklist: Flags.string({
+        description: 'Fields forbidden to be written. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+};
+export const updateFlags = {
+    ...resourceBaseFlags,
+    ...resourceAssociationFlags,
+    'filter-by-tk': Flags.string({
+        description: 'Primary key value used by update. Supports JSON arrays for composite or multiple keys.',
+    }),
+    filter: Flags.string({
+        description: 'Filter object for update as JSON.',
+    }),
+    values: Flags.string({
+        description: 'Record values used by update as a JSON object.',
+        required: true,
+    }),
+    whitelist: Flags.string({
+        description: 'Fields allowed to be written. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    blacklist: Flags.string({
+        description: 'Fields forbidden to be written. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    'update-association-values': Flags.string({
+        description: 'Association fields that should be updated together. Repeat the flag or pass a JSON array.',
+        multiple: true,
+    }),
+    'force-update': Flags.boolean({
+        description: 'Whether update should force writing unchanged values.',
+        allowNo: true,
+    }),
+};
+export const destroyFlags = {
+    ...resourceBaseFlags,
+    ...resourceAssociationFlags,
+    'filter-by-tk': Flags.string({
+        description: 'Primary key value used by destroy. Supports JSON arrays for composite or multiple keys.',
+    }),
+    filter: Flags.string({
+        description: 'Filter object for destroy as JSON.',
+    }),
+};
+export const queryFlags = {
+    ...resourceBaseFlags,
+    measures: Flags.string({
+        description: 'Measure definitions for query aggregation as a JSON array.',
+    }),
+    dimensions: Flags.string({
+        description: 'Dimension definitions for query aggregation as a JSON array.',
+    }),
+    orders: Flags.string({
+        description: 'Order definitions for query aggregation as a JSON array.',
+    }),
+    filter: Flags.string({
+        description: 'Filter object for query as JSON.',
+    }),
+    having: Flags.string({
+        description: 'Having object for grouped query as JSON.',
+    }),
+    limit: Flags.integer({
+        description: 'Limit for query result rows.',
+    }),
+    offset: Flags.integer({
+        description: 'Offset for query result rows.',
+    }),
+    timezone: Flags.string({
+        description: 'Optional timezone for query formatting.',
+    }),
+};
+function pickSharedArgs(flags) {
+    return {
+        resource: flags.resource,
+        dataSource: flags['data-source'],
+        sourceId: parseFlexibleValue(flags['source-id'], 'source-id'),
+    };
+}
+export function buildListArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        filter: parseObjectFlag(flags.filter, 'filter'),
+        fields: parseStringArrayFlags(flags.fields, 'fields'),
+        appends: parseStringArrayFlags(flags.appends, 'appends'),
+        except: parseStringArrayFlags(flags.except, 'except'),
+        sort: parseStringArrayFlags(flags.sort, 'sort'),
+        page: flags.page,
+        pageSize: flags['page-size'],
+        paginate: flags.paginate,
+    };
+}
+export function buildGetArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        filterByTk: parseFlexibleValue(flags['filter-by-tk'], 'filter-by-tk'),
+        fields: parseStringArrayFlags(flags.fields, 'fields'),
+        appends: parseStringArrayFlags(flags.appends, 'appends'),
+        except: parseStringArrayFlags(flags.except, 'except'),
+    };
+}
+export function buildCreateArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        values: parseObjectFlag(flags.values, 'values'),
+        whitelist: parseStringArrayFlags(flags.whitelist, 'whitelist'),
+        blacklist: parseStringArrayFlags(flags.blacklist, 'blacklist'),
+    };
+}
+export function buildUpdateArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        filterByTk: parseFlexibleValue(flags['filter-by-tk'], 'filter-by-tk'),
+        filter: parseObjectFlag(flags.filter, 'filter'),
+        values: parseObjectFlag(flags.values, 'values'),
+        whitelist: parseStringArrayFlags(flags.whitelist, 'whitelist'),
+        blacklist: parseStringArrayFlags(flags.blacklist, 'blacklist'),
+        updateAssociationValues: parseStringArrayFlags(flags['update-association-values'], 'update-association-values'),
+        forceUpdate: flags['force-update'],
+    };
+}
+export function buildDestroyArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        filterByTk: parseFlexibleValue(flags['filter-by-tk'], 'filter-by-tk'),
+        filter: parseObjectFlag(flags.filter, 'filter'),
+    };
+}
+export function buildQueryArgs(flags) {
+    return {
+        ...pickSharedArgs(flags),
+        measures: parseJsonArrayFlag(flags.measures, 'measures'),
+        dimensions: parseJsonArrayFlag(flags.dimensions, 'dimensions'),
+        orders: parseJsonArrayFlag(flags.orders, 'orders'),
+        filter: parseObjectFlag(flags.filter, 'filter'),
+        having: parseObjectFlag(flags.having, 'having'),
+        limit: flags.limit,
+        offset: flags.offset,
+        timezone: flags.timezone,
+    };
+}
+export async function runResourceCommand(command, action, flags, args) {
+    setVerboseMode(Boolean(flags.verbose));
+    const response = await executeResourceRequest({
+        envName: flags.env,
+        baseUrl: flags['base-url'],
+        role: flags.role,
+        token: flags.token,
+        action,
+        args,
+    });
+    printResponse(command, response, flags['json-output']);
+}