@nocobase/cli 2.1.0-alpha.3 → 2.1.0-alpha.31

package/dist/lib/api-client.js

@@ -0,0 +1,329 @@
+/**
+ * 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.
+ */
+/**
+ * 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 { createWriteStream } from 'node:fs';
+import { promises as fs } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { resolveServerRequestTarget } from './env-auth.js';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
+const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
+const CLI_REQUEST_SOURCE_VALUE = 'cli';
+function stripUtf8Bom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function parseJsonInput(raw, flagName) {
+    const content = stripUtf8Bom(raw);
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON for --${flagName}: ${error?.message ?? 'parse failed'}`);
+    }
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    let data = text;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            data = text;
+        }
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        data,
+    };
+}
+async function parseBinaryResponse(response, outputPath) {
+    if (response.ok && response.body) {
+        await fs.mkdir(dirname(outputPath), { recursive: true }).catch(() => undefined);
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: {
+                output: outputPath,
+            },
+        };
+    }
+    return parseResponse(response);
+}
+function parseScalarValue(value, type) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (type === 'boolean') {
+        return value;
+    }
+    if (type === 'integer' || type === 'number') {
+        return Number(value);
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    return value;
+}
+function hasParameterValue(flags, parameter) {
+    const value = flags[parameter.flagName];
+    if (parameter.type === 'boolean') {
+        return value !== undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, parameters) {
+    return parameters
+        .filter((parameter) => hasParameterValue(flags, parameter))
+        .map((parameter) => `--${parameter.flagName}`);
+}
+function parseBodyFieldValue(rawValue, parameter) {
+    if (rawValue === undefined) {
+        return undefined;
+    }
+    if (parameter.isArray && !parameter.jsonEncoded) {
+        return Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined;
+    }
+    if (parameter.jsonEncoded || parameter.type === 'object' || parameter.type === 'array') {
+        if (typeof rawValue !== 'string') {
+            return rawValue;
+        }
+        const parsed = parseJsonInput(rawValue, parameter.flagName);
+        if (parameter.type === 'array' && !Array.isArray(parsed)) {
+            throw new Error(`--${parameter.flagName} must be a JSON array`);
+        }
+        if (parameter.type === 'object' && (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object')) {
+            throw new Error(`--${parameter.flagName} must be a JSON object`);
+        }
+        return parsed;
+    }
+    return parseScalarValue(rawValue, parameter.type);
+}
+export async function parseBody(flags, operation) {
+    if (operation.requestContentType === 'multipart/form-data') {
+        return undefined;
+    }
+    const inlineBody = flags.body;
+    const bodyFile = flags['body-file'];
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const hasBodyFlags = bodyParameters.some((parameter) => hasParameterValue(flags, parameter));
+    if ((inlineBody || bodyFile) && hasBodyFlags) {
+        const providedBodyFlags = listProvidedBodyFlags(flags, bodyParameters);
+        const rawBodyInput = inlineBody ? '--body' : '--body-file';
+        throw new Error(`Conflicting request body inputs: received ${rawBodyInput} together with body field flags (${providedBodyFlags.join(', ')}). Use either body field flags or --body/--body-file.`);
+    }
+    if (inlineBody) {
+        return parseJsonInput(inlineBody, 'body');
+    }
+    if (bodyFile) {
+        return fs.readFile(bodyFile, 'utf8').then((content) => parseJsonInput(content, 'body-file'));
+    }
+    if (!bodyParameters.length) {
+        return undefined;
+    }
+    const body = {};
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const value = parseBodyFieldValue(rawValue, parameter);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        body[parameter.name] = value;
+    }
+    if (Object.keys(body).length > 0) {
+        return body;
+    }
+    if (operation.hasBody && operation.bodyRequired) {
+        throw new Error('Missing request body. Use body field flags or --body/--body-file.');
+    }
+    return undefined;
+}
+async function createMultipartBody(flags, operation) {
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const formData = new FormData();
+    let hasValues = false;
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const hasValue = hasParameterValue(flags, parameter);
+        if (parameter.required && !hasValue) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (!hasValue) {
+            continue;
+        }
+        if (parameter.isFile) {
+            const filePath = String(rawValue);
+            const content = await fs.readFile(filePath);
+            const arrayBuffer = content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength);
+            formData.append(parameter.name, new Blob([arrayBuffer]), basename(filePath));
+            hasValues = true;
+            continue;
+        }
+        const value = parseBodyFieldValue(rawValue, parameter);
+        if (value === undefined) {
+            continue;
+        }
+        formData.append(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+        hasValues = true;
+    }
+    if (!hasValues && operation.bodyRequired) {
+        throw new Error('Missing multipart request body.');
+    }
+    return hasValues ? formData : undefined;
+}
+export async function executeApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    const query = new URLSearchParams();
+    let requestPath = options.operation.pathTemplate;
+    for (const parameter of options.operation.parameters) {
+        if (parameter.in === 'body') {
+            continue;
+        }
+        const rawValue = options.flags[parameter.flagName];
+        const value = parameter.isArray
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required parameter --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (parameter.in === 'path') {
+            requestPath = requestPath.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+            continue;
+        }
+        if (parameter.in === 'query') {
+            if (Array.isArray(value)) {
+                value.forEach((item) => query.append(parameter.name, String(parseScalarValue(item, parameter.type))));
+            }
+            else if (typeof value === 'object') {
+                query.set(parameter.name, JSON.stringify(value));
+            }
+            else {
+                query.set(parameter.name, String(value));
+            }
+            continue;
+        }
+        if (parameter.in === 'header') {
+            headers.set(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+            continue;
+        }
+    }
+    const body = options.operation.requestContentType === 'multipart/form-data'
+        ? await createMultipartBody(options.flags, options.operation)
+        : await parseBody(options.flags, options.operation);
+    if (body !== undefined && options.operation.requestContentType !== 'multipart/form-data') {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
+    query.forEach((value, key) => url.searchParams.append(key, value));
+    const response = await fetchWithPreservedAuthRedirect(url.toString(), {
+        method: options.operation.method.toUpperCase(),
+        headers,
+        body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
+    });
+    if (options.operation.responseType === 'binary') {
+        const outputPath = options.flags.output;
+        if (!outputPath) {
+            throw new Error('Missing required output path --output');
+        }
+        return parseBinaryResponse(response, outputPath);
+    }
+    return parseResponse(response);
+}
+export async function executeRawApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        headers.set(name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    if (options.body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${options.path}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, typeof item === 'object' ? JSON.stringify(item) : String(item));
+            }
+            continue;
+        }
+        url.searchParams.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    const controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController() : undefined;
+    const timeout = controller
+        ? setTimeout(() => {
+            controller.abort();
+        }, options.timeoutMs)
+        : undefined;
+    try {
+        const response = await fetchWithPreservedAuthRedirect(url.toString(), {
+            method: options.method.toUpperCase(),
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal: controller?.signal,
+        });
+        return parseResponse(response);
+    }
+    finally {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/lib/app-health.js

@@ -0,0 +1,126 @@
+/**
+ * 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 { printInfo, startTask, stopTask, updateTask } from './ui.js';
+const APP_HEALTH_CHECK_INTERVAL_MS = 2_000;
+const APP_HEALTH_CHECK_TIMEOUT_MS = 600_000;
+const APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS = 5_000;
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function buildHealthCheckUrl(apiBaseUrl) {
+    return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestAppHealthCheck(params) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await (params.fetchImpl ?? fetch)(params.healthCheckUrl, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        const text = await response.text().catch(() => '');
+        const body = text.replace(/\s+/g, ' ').trim() || 'No response yet';
+        return {
+            ok: response.ok && text.trim().toLowerCase() === 'ok',
+            message: `HTTP ${response.status}: ${body}`,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return {
+                ok: false,
+                message: `No response within ${Math.ceil((params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS) / 1000)}s`,
+            };
+        }
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export class AppHealthCheckError extends Error {
+}
+export function formatAppUrl(port) {
+    const value = trimValue(port);
+    return value ? `http://127.0.0.1:${value}` : undefined;
+}
+export function resolveManagedAppApiBaseUrl(runtime, options) {
+    const override = trimValue(options?.portOverride);
+    if (override) {
+        return `http://127.0.0.1:${override}/api`;
+    }
+    const baseUrl = trimValue(runtime.env.baseUrl);
+    if (baseUrl) {
+        return baseUrl.replace(/\/+$/, '');
+    }
+    const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
+        ? ''
+        : trimValue(runtime.env.appPort);
+    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
+}
+export async function isAppReady(apiBaseUrl, options) {
+    const baseUrl = trimValue(apiBaseUrl);
+    if (!baseUrl) {
+        return false;
+    }
+    const result = await requestAppHealthCheck({
+        healthCheckUrl: buildHealthCheckUrl(baseUrl),
+        fetchImpl: options?.fetchImpl,
+        requestTimeoutMs: options?.requestTimeoutMs,
+    });
+    return result.ok;
+}
+export async function waitForAppReady(params) {
+    const apiBaseUrl = trimValue(params.apiBaseUrl);
+    if (!apiBaseUrl) {
+        printInfo(`Skipping health check for "${params.envName}" because no local API URL is saved for this env.`);
+        return;
+    }
+    const healthCheckUrl = buildHealthCheckUrl(apiBaseUrl);
+    const startedAt = Date.now();
+    let lastMessage = 'No response yet';
+    let spinnerActive = true;
+    startTask(`Waiting for NocoBase to become ready for "${params.envName}"...`);
+    try {
+        while (Date.now() - startedAt < APP_HEALTH_CHECK_TIMEOUT_MS) {
+            const result = await requestAppHealthCheck({
+                healthCheckUrl,
+                fetchImpl: params.fetchImpl,
+            });
+            if (result.ok) {
+                stopTask();
+                spinnerActive = false;
+                return;
+            }
+            lastMessage = result.message;
+            const elapsedSeconds = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
+            updateTask(`Waiting for NocoBase to become ready for "${params.envName}"... (${elapsedSeconds}s elapsed, last status: ${lastMessage})`);
+            await sleep(APP_HEALTH_CHECK_INTERVAL_MS);
+        }
+    }
+    finally {
+        if (spinnerActive) {
+            stopTask();
+        }
+    }
+    const hints = [
+        params.logHint,
+        params.containerName ? `docker logs ${params.containerName}` : undefined,
+    ].filter(Boolean);
+    const hintText = hints.length > 0 ? ` ${hints.join(' ')}` : '';
+    throw new AppHealthCheckError(`NocoBase did not become ready in time for "${params.envName}". Expected \`${healthCheckUrl}\` to respond with \`ok\`, but the last status was: ${lastMessage}.${hintText}`);
+}